Metrics for Numeric.SpecFunctions:logBeta from math-functions-0.1.5.2, B

start0.0ms (0%)

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

analyze19.0ms (0.3%)

Memory

-20.0MiB live, 26.1MiB allocated; 7ms collecting garbage

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.6%	0.4%	0%	0%	0%	0
0%	0%	99.6%	0.4%	0%	0%	0%	1
0%	0%	99.6%	0.4%	0%	0%	0%	2
0%	0%	49.8%	0.4%	0%	49.8%	0%	3
0%	0%	49.8%	0.4%	0%	49.8%	0%	4
0%	0%	49.8%	0.4%	0%	49.8%	0%	5
0%	0%	49.8%	0.4%	0%	49.8%	0%	6
0%	0%	49.8%	0.4%	0%	49.8%	0%	7
100%	24.9%	0%	0.4%	0%	74.7%	0%	8

Compiler

Compiled 23 to 22 computations (4.3% saved)

sample1.7s (27%)

Memory

37.3MiB live, 2 069.1MiB allocated; 482ms collecting garbage

Samples

1.0s	8 252×	0	valid
1.0ms	4×	1	valid

Precisions

Click to see histograms. Total time spent on operations: 581.0ms

ival-mult!: 225.0ms (38.7% of total)

ival-log: 202.0ms (34.7% of total)

ival-add!: 131.0ms (22.5% of total)

ival-sub!: 22.0ms (3.8% of total)

adjust: 2.0ms (0.3% of total)

Bogosity

explain230.0ms (3.7%)

Memory

23.2MiB live, 355.9MiB allocated; 26ms collecting garbage

FPErrors

Click to see full error table

Example	Example	Subexpression
-	-	`a`
-	-	`(log.f64 y)`
-	-	`(+.f64 (*.f64 x (log.f64 y)) z)`
-	-	`t`
-	-	`(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)`
-	-	`c`
-	-	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
-	-	`y`
-	-	`i`
-	-	`(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)`
-	-	`#s(literal 1/2 binary64)`
-	-	`(log.f64 c)`
-	-	`(*.f64 x (log.f64 y))`
-	-	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`
-	-	`z`
-	-	`(*.f64 y i)`
-	-	`(-.f64 b #s(literal 1/2 binary64))`
-	-	`(+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))`
-	-	`b`
-	-	`x`

Confusion

	Predicted +	Predicted -
+	0	0
-	0	256

Precision

0/0

Recall

0/0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	0	0	0
-	0	0	256

Precision?

0/0

Recall?

0/0

Freqs

test

number	freq
0	256

Total Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	0	0	0
-	0	0	1

Precision?

0/0

Recall?

0/0

Samples

60.0ms

512×

valid

Compiler

Compiled 207 to 64 computations (69.1% saved)

Precisions

Click to see histograms. Total time spent on operations: 31.0ms

ival-log: 14.0ms (45.3% of total)

ival-mult!: 8.0ms (25.9% of total)

ival-add!: 7.0ms (22.6% of total)

ival-sub!: 1.0ms (3.2% of total)

adjust: 0.0ms (0% of total)

preprocess45.0ms (0.7%)

Memory

-21.0MiB live, 70.2MiB allocated; 8ms collecting garbage

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	245	969
1	791	965
2	3526	962
3	5742	962

Stop Event

1×	node-limit

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	99.8%	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))

Symmetry

(sort z t a)

Compiler

Compiled 42 to 40 computations (4.8% saved)

series319.0ms (5.1%)

Memory

22.1MiB live, 488.6MiB allocated; 102ms collecting garbage

Counts

20 → 130

Calls

Call 1

Inputs
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)
(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)
(+.f64 (*.f64 x (log.f64 y)) z)
(*.f64 x (log.f64 y))
x
(log.f64 y)
y
z
t
a
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
(*.f64 y i)
i

Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 z))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* x (log y)) #s(hole binary64 (* x (log y))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* x (log y))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (* y i) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 y)))))))
#s(approx (* x (log y)) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (* x (log y)) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx z #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (- b 1/2) #s(hole binary64 -1/2))
#s(approx (- b 1/2) #s(hole binary64 (- b 1/2)))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (- b 1/2) #s(hole binary64 b))
#s(approx (- b 1/2) #s(hole binary64 (* b (- 1 (* 1/2 (/ 1 b))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))))
#s(approx (- b 1/2) #s(hole binary64 (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (log c) #s(hole binary64 (log c)))
#s(approx c #s(hole binary64 c))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* (log (/ 1 c)) (- b 1/2)))))
#s(approx (log c) #s(hole binary64 (* -1 (log (/ 1 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
#s(approx (log c) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 c))))))
#s(approx i #s(hole binary64 i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))

Calls

24 calls:

Time	Variable		Point	Expression
74.0ms	y	@	-inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* x (log y)) x (log y) y z t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i)
45.0ms	x	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* x (log y)) x (log y) y z t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i)
37.0ms	y	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* x (log y)) x (log y) y z t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i)
24.0ms	y	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* x (log y)) x (log y) y z t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i)
22.0ms	i	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* x (log y)) x (log y) y z t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i)

rewrite205.0ms (3.3%)

Memory

25.2MiB live, 250.8MiB allocated; 44ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	518	3503
0	537	3355
1	3530	3330
0	9768	3076

Stop Event

1×	iter-limit
1×	node-limit
1×	iter-limit

Counts

150 → 203

Calls

Call 1

Inputs
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)
(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)
(+.f64 (*.f64 x (log.f64 y)) z)
(*.f64 x (log.f64 y))
x
(log.f64 y)
y
z
t
a
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
(*.f64 y i)
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 z))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* x (log y)) #s(hole binary64 (* x (log y))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* x (log y))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (* y i) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 y)))))))
#s(approx (* x (log y)) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (* x (log y)) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx z #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (- b 1/2) #s(hole binary64 -1/2))
#s(approx (- b 1/2) #s(hole binary64 (- b 1/2)))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (- b 1/2) #s(hole binary64 b))
#s(approx (- b 1/2) #s(hole binary64 (* b (- 1 (* 1/2 (/ 1 b))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))))
#s(approx (- b 1/2) #s(hole binary64 (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (log c) #s(hole binary64 (log c)))
#s(approx c #s(hole binary64 c))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* (log (/ 1 c)) (- b 1/2)))))
#s(approx (log c) #s(hole binary64 (* -1 (log (/ 1 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
#s(approx (log c) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 c))))))
#s(approx i #s(hole binary64 i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))

Outputs
(/.f64 (fma.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (.f64 a a)) (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (-.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))))) (.f64 (-.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a) (-.f64 (.f64 i y) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (.f64 a a)) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (.f64 (-.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a) (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))))) (.f64 (-.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.f64 i y) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64))) (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (-.f64 a (fma.f64 (log.f64 y) x (+.f64 t z))) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))))) (.f64 (-.f64 a (fma.f64 (log.f64 y) x (+.f64 t z))) (-.f64 (.f64 i y) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (.f64 (-.f64 a (fma.f64 (log.f64 y) x (+.f64 t z))) (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))))) (.f64 (-.f64 a (fma.f64 (log.f64 y) x (+.f64 t z))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.f64 i y) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a))) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))))) (.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a))) (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a))) (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))))) (.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 3 binary64))) (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (fma.f64 a a (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 t z))))) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))))) (.f64 (fma.f64 a a (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 t z))))) (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (.f64 (fma.f64 a a (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 t z))))) (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))))) (.f64 (fma.f64 a a (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 t z))))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))) #s(literal 2 binary64)) (pow.f64 (.f64 i y) #s(literal 2 binary64))) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))) (.f64 i y)))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))) #s(literal 3 binary64)) (pow.f64 (.f64 i y) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))) (.f64 i y)))))
(fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))))
(-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))) (*.f64 (neg.f64 y) i))
(+.f64 (*.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))) (*.f64 i y))
(+.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)))
(/.f64 (-.f64 (pow.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)))
(-.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)) (*.f64 (neg.f64 (-.f64 b #s(literal 1/2 binary64))) (log.f64 c)))
(+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)))
(+.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) (+.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64))) (-.f64 a (fma.f64 (log.f64 y) x (+.f64 t z))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a))))
(/.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 3 binary64))) (fma.f64 a a (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) #s(literal 2 binary64)) (*.f64 a (fma.f64 (log.f64 y) x (+.f64 t z))))))
(+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))
(+.f64 (fma.f64 (log.f64 y) x z) (+.f64 t a))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a)
(+.f64 a (fma.f64 (log.f64 y) x (+.f64 t z)))
(/.f64 (-.f64 (*.f64 t t) (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64))) (-.f64 t (fma.f64 (log.f64 y) x z)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (*.f64 t t)) (-.f64 (fma.f64 (log.f64 y) x z) t))
(/.f64 (+.f64 (pow.f64 t #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64))) (fma.f64 t t (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (*.f64 t (fma.f64 (log.f64 y) x z)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (.f64 t t) (.f64 (fma.f64 (log.f64 y) x z) t))))
(fma.f64 (log.f64 y) x (+.f64 t z))
(fma.f64 x (log.f64 y) (+.f64 t z))
(+.f64 (fma.f64 (log.f64 y) x z) t)
(+.f64 (+.f64 t z) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) (+.f64 t z))
(+.f64 t (fma.f64 (log.f64 y) x z))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z z)) (-.f64 (*.f64 (log.f64 y) x) z))
(/.f64 (-.f64 (.f64 z z) (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64))) (-.f64 z (*.f64 (log.f64 y) x)))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (.f64 z z) (.f64 (*.f64 (log.f64 y) x) z))))
(/.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z (.f64 (log.f64 y) x)))))
(fma.f64 (log.f64 y) x z)
(fma.f64 x (log.f64 y) z)
(-.f64 z (*.f64 (neg.f64 x) (log.f64 y)))
(+.f64 (*.f64 (log.f64 y) x) z)
(+.f64 z (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(*.f64 x (log.f64 y))
(log.f64 (pow.f64 y x))
x
(log.f64 y)
y
z
t
a
(*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(log.f64 (pow.f64 c (-.f64 b #s(literal 1/2 binary64))))
(/.f64 (-.f64 (*.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64)))
(/.f64 (-.f64 (pow.f64 b #s(literal 3 binary64)) #s(literal 1/8 binary64)) (fma.f64 b b (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
(*.f64 i y)
(*.f64 y i)
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 t z) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)))
#s(approx (+ (+ (* x (log y)) z) t) (+.f64 t z))
#s(approx (+ (+ (* x (log y)) z) t) (fma.f64 (log.f64 y) x (+.f64 t z)))
#s(approx (+ (* x (log y)) z) z)
#s(approx (+ (* x (log y)) z) (fma.f64 (log.f64 y) x z))
#s(approx (* x (log y)) (*.f64 (log.f64 y) x))
#s(approx x x)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (/.f64 (+.f64 t z) x) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) x))) x))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t z) a) x) (log.f64 y)) x))
#s(approx (+ (+ (* x (log y)) z) t) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (+.f64 t z) x) (log.f64 y)) x))
#s(approx (+ (* x (log y)) z) (*.f64 (log.f64 y) x))
#s(approx (+ (* x (log y)) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) z)) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* x (log y)) z) t) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 t z) x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* x (log y)) z) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 z x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (log y) (log.f64 y))
#s(approx y y)
#s(approx (* y i) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 a t) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z)))
#s(approx (+ (+ (* x (log y)) z) t) (+.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z) t))
#s(approx (+ (* x (log y)) z) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z))
#s(approx (* x (log y)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))
#s(approx (log y) (neg.f64 (neg.f64 (log.f64 y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (neg.f64 y) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) y) #s(literal -1 binary64) (neg.f64 i))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 a t) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z)))
#s(approx (+ (+ (* x (log y)) z) t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t))
#s(approx (+ (* x (log y)) z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z))
#s(approx (* x (log y)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x))
#s(approx (log y) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (fma.f64 (log.f64 y) x t) a))
#s(approx (+ (+ (* x (log y)) z) t) (fma.f64 (log.f64 y) x t))
#s(approx z z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) z)) (/.f64 t z))) z))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z)
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x t) z) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) z))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) z)
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) #s(literal 1 binary64)) z))
#s(approx (+ (+ (* x (log y)) z) t) z)
#s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x t) z) #s(literal 1 binary64)) z))
#s(approx (+ (* x (log y)) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* x (log y)) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x t) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* x (log y)) z) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (.f64 (log.f64 y) x) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (fma.f64 (log.f64 y) x z) a))
#s(approx (+ (+ (* x (log y)) z) t) (fma.f64 (log.f64 y) x z))
#s(approx t t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (+.f64 (fma.f64 i (/.f64 y t) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t)) (/.f64 z t))) t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t)
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) t)
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) a) t) #s(literal 1 binary64)) t))
#s(approx (+ (+ (* x (log y)) z) t) t)
#s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) a) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* x (log y)) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x z) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (fma.f64 (log.f64 y) x (+.f64 t z)))
#s(approx a a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t a)) (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) a)) (/.f64 z a))) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a)
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t a)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) a)
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a) #s(literal 1 binary64)) a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 i y))) z) t) a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 (log.f64 y) x (*.f64 i y))) z)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x)) z)))
#s(approx (* (- b 1/2) (log c)) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b)))
#s(approx (- b 1/2) #s(literal -1/2 binary64))
#s(approx (- b 1/2) (-.f64 b #s(literal 1/2 binary64)))
#s(approx b b)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x (.f64 i y)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) b) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) b))
#s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))
#s(approx (- b 1/2) b)
#s(approx (- b 1/2) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 #s(literal 1/2 binary64) b)) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 (log.f64 y) x)) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (* (- b 1/2) (log c)) (neg.f64 (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal 1/2 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (- b 1/2) (neg.f64 (*.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) b) #s(literal 1 binary64)) b)))
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (log c) (log.f64 c))
#s(approx c c)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x (*.f64 i y)))) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) a))
#s(approx (* (- b 1/2) (log c)) (*.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (log c) (neg.f64 (neg.f64 (log.f64 c))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 i y (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (log c) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx i i)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (/.f64 t i) (/.f64 z i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i))) i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))

eval25.0ms (0.4%)

Memory: -4.6MiB live, 40.4MiB allocated; 7ms collecting garbage
Compiler: Compiled 6 494 to 995 computations (84.7% saved)

prune34.0ms (0.5%)

Memory

-16.5MiB live, 30.4MiB allocated; 3ms collecting garbage

Pruning

25 alts after pruning (25 fresh and 0 done)

	Pruned	Kept	Total
New	161	25	186
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	162	25	187

Accuracy

100.0%

Counts

187 → 25

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	91.8%	(+.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
	86.5%	(+.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
▶	76.5%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
	80.4%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) z) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
▶	57.3%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
	54.8%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (log.f64 y) x)) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
	60.9%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
	38.4%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) t) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
	56.6%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
	81.2%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) (*.f64 y i))
	78.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t a)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a)) (*.f64 y i))
	67.1%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t)) (*.f64 y i))
	35.4%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
	24.7%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
▶	42.1%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
	78.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
	69.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
	66.2%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))
	19.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
	14.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
	23.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
	72.2%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
	24.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
	3.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
▶	20.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 1 528 to 1 278 computations (16.4% saved)

series353.0ms (5.6%)

Memory

2.8MiB live, 330.1MiB allocated; 181ms collecting garbage

Counts

38 → 197

Calls

Call 1

Inputs
(+.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)) t) a)
(+.f64 #s(approx (+ (* x (log y)) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)) t)
#s(approx (+ (* x (log y)) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z))
(*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)
(fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64))
x
(/.f64 (log.f64 y) z)
(log.f64 y)
y
z
#s(literal 1 binary64)
t
a
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
(*.f64 y i)
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a)
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)
#s(approx (+ (+ (* x (log y)) z) t) t)
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)
#s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t))
(*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)
(+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64))
(/.f64 (fma.f64 (log.f64 y) x z) t)
(fma.f64 (log.f64 y) x z)

Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 z))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 z))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 1))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (+ 1 (/ (* x (log y)) z))))
#s(approx x #s(hole binary64 x))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ z t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ (* t (+ 1 (/ z t))) (* x (log y)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (/ z t))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (/ z t) (/ (* x (log y)) t)))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (/ z t)))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (+ (/ z t) (/ (* x (log y)) t))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 z))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* x (log y))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ (log y) z)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (+ (log y) (/ (* t (+ 1 (/ z t))) x)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (* x (log y)) t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* x (+ (/ 1 x) (+ (/ z (* t x)) (/ (log y) t))))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (/ (* x (log y)) t)))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (* x (+ (/ z (* t x)) (/ (log y) t)))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (log y) z)) (/ 1 x))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* t (+ 1 (/ z t))) x)))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) t)) (* -1 (/ (+ 1 (/ z t)) x)))))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (/ z (* t x))) (* -1 (/ (log y) t)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (/ (log y) z) #s(hole binary64 (/ (log y) z)))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (* y i) #s(hole binary64 (* i y)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (/ (+ z (* x (log y))) t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 y)))))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* z (+ 1 (* -1 (/ (* x (log (/ 1 y))) z))))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (* x (log (/ 1 y))) z)))))
#s(approx (/ (log y) z) #s(hole binary64 (* -1 (/ (log (/ 1 y)) z))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) t)) (/ z t))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) t)) (/ z t)))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (/ (+ z (* -1 (* x (log (/ 1 y))))) t)))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 y)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* z (+ 1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (+ 1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z))))
#s(approx (/ (log y) z) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 y)))) z)))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (/ z t) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t)))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (/ (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))) t)))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (/ (+ z (* x (log y))) z)))
#s(approx z #s(hole binary64 z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ (* x (log y)) t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* t (+ 1 (/ (* x (log y)) t))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (/ (* x (log y)) t))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* z (+ 1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ z t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* z (+ (/ 1 t) (+ (/ 1 z) (/ (* x (log y)) (* t z)))))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (* z (+ (/ 1 t) (/ (* x (log y)) (* t z))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)) 1)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ 1 (/ (* x (log y)) t)) z)) (/ 1 t))))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) (* t z))) (/ 1 t))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx t #s(hole binary64 t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (+ z (* x (log y))) t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (+ t (+ z (* x (log y)))) t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 1))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (- b 1/2) #s(hole binary64 -1/2))
#s(approx (- b 1/2) #s(hole binary64 (- b 1/2)))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (- b 1/2) #s(hole binary64 b))
#s(approx (- b 1/2) #s(hole binary64 (* b (- 1 (* 1/2 (/ 1 b))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))))
#s(approx (- b 1/2) #s(hole binary64 (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (log c) #s(hole binary64 (log c)))
#s(approx c #s(hole binary64 c))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* (log (/ 1 c)) (- b 1/2)))))
#s(approx (log c) #s(hole binary64 (* -1 (log (/ 1 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
#s(approx (log c) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 c))))))
#s(approx i #s(hole binary64 i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))

Calls

24 calls:

Time	Variable		Point	Expression
109.0ms	b	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* (+ (* x (/ (log y) z)) 1) z) (+ (* x (/ (log y) z)) 1) x (/ (log y) z) (log y) y z 1 t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (/ (+ (* (log y) x) z) t) 1) (/ (+ (* (log y) x) z) t) (+ (* (log y) x) z))
41.0ms	c	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* (+ (* x (/ (log y) z)) 1) z) (+ (* x (/ (log y) z)) 1) x (/ (log y) z) (log y) y z 1 t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (/ (+ (* (log y) x) z) t) 1) (/ (+ (* (log y) x) z) t) (+ (* (log y) x) z))
21.0ms	y	@	-inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* (+ (* x (/ (log y) z)) 1) z) (+ (* x (/ (log y) z)) 1) x (/ (log y) z) (log y) y z 1 t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (/ (+ (* (log y) x) z) t) 1) (/ (+ (* (log y) x) z) t) (+ (* (log y) x) z))
20.0ms	y	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* (+ (* x (/ (log y) z)) 1) z) (+ (* x (/ (log y) z)) 1) x (/ (log y) z) (log y) y z 1 t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (/ (+ (* (log y) x) z) t) 1) (/ (+ (* (log y) x) z) t) (+ (* (log y) x) z))
16.0ms	z	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (* x (log y)) z) (* (+ (* x (/ (log y) z)) 1) z) (+ (* x (/ (log y) z)) 1) x (/ (log y) z) (log y) y z 1 t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (/ (+ (* (log y) x) z) t) 1) (/ (+ (* (log y) x) z) t) (+ (* (log y) x) z))

rewrite213.0ms (3.4%)

Memory

-34.0MiB live, 294.4MiB allocated; 45ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	693	5187
0	731	4817
1	4520	4801
0	8268	4636

Stop Event

1×	iter-limit
1×	node-limit
1×	iter-limit

Counts

235 → 344

Calls

Call 1

Inputs
(+.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)) t) a)
(+.f64 #s(approx (+ (* x (log y)) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)) t)
#s(approx (+ (* x (log y)) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z))
(*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)
(fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64))
x
(/.f64 (log.f64 y) z)
(log.f64 y)
y
z
#s(literal 1 binary64)
t
a
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
(*.f64 y i)
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a)
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)
#s(approx (+ (+ (* x (log y)) z) t) t)
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)
#s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t))
(*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)
(+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64))
(/.f64 (fma.f64 (log.f64 y) x z) t)
(fma.f64 (log.f64 y) x z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 z))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 z))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 1))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (+ 1 (/ (* x (log y)) z))))
#s(approx x #s(hole binary64 x))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ z t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ (* t (+ 1 (/ z t))) (* x (log y)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (/ z t))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (/ z t) (/ (* x (log y)) t)))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (/ z t)))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (+ (/ z t) (/ (* x (log y)) t))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 z))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* x (log y))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ (log y) z)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (+ (log y) (/ (* t (+ 1 (/ z t))) x)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (* x (log y)) t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* x (+ (/ 1 x) (+ (/ z (* t x)) (/ (log y) t))))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (/ (* x (log y)) t)))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (* x (+ (/ z (* t x)) (/ (log y) t)))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (log y) z)) (/ 1 x))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* t (+ 1 (/ z t))) x)))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) t)) (* -1 (/ (+ 1 (/ z t)) x)))))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (/ z (* t x))) (* -1 (/ (log y) t)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (/ (log y) z) #s(hole binary64 (/ (log y) z)))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx y #s(hole binary64 y))
#s(approx (* y i) #s(hole binary64 (* i y)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (/ (+ z (* x (log y))) t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 y)))))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* z (+ 1 (* -1 (/ (* x (log (/ 1 y))) z))))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (+ 1 (* -1 (/ (* x (log (/ 1 y))) z)))))
#s(approx (/ (log y) z) #s(hole binary64 (* -1 (/ (log (/ 1 y)) z))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) t)) (/ z t))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) t)) (/ z t)))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (/ (+ z (* -1 (* x (log (/ 1 y))))) t)))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 y)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* z (+ 1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (+ 1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z))))
#s(approx (/ (log y) z) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 y)))) z)))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (/ z t) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t)))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (/ (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))) t)))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx (+ (* x (/ (log y) z)) 1) #s(hole binary64 (/ (+ z (* x (log y))) z)))
#s(approx z #s(hole binary64 z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ (* x (log y)) t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* t (+ 1 (/ (* x (log y)) t))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (/ (* x (log y)) t))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* z (+ 1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ z t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* z (+ (/ 1 t) (+ (/ 1 z) (/ (* x (log y)) (* t z)))))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (* z (+ (/ 1 t) (/ (* x (log y)) (* t z))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (+ (* x (log y)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)) 1)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ 1 (/ (* x (log y)) t)) z)) (/ 1 t))))))
#s(approx (/ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) (* t z))) (/ 1 t))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx t #s(hole binary64 t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (+ z (* x (log y))) t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (+ t (+ z (* x (log y)))) t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 1))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (- b 1/2) #s(hole binary64 -1/2))
#s(approx (- b 1/2) #s(hole binary64 (- b 1/2)))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (- b 1/2) #s(hole binary64 b))
#s(approx (- b 1/2) #s(hole binary64 (* b (- 1 (* 1/2 (/ 1 b))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))))
#s(approx (- b 1/2) #s(hole binary64 (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (log c) #s(hole binary64 (log c)))
#s(approx c #s(hole binary64 c))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* (log (/ 1 c)) (- b 1/2)))))
#s(approx (log c) #s(hole binary64 (* -1 (log (/ 1 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
#s(approx (log c) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 c))))))
#s(approx i #s(hole binary64 i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))

Outputs
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))) #s(literal 2 binary64)) (pow.f64 (.f64 i y) #s(literal 2 binary64))) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))) (.f64 i y)))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))) #s(literal 3 binary64)) (pow.f64 (.f64 i y) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ ( (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))) (.f64 i y)))))
(fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))))
(-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))) (.f64 (neg.f64 y) i))
(+.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ ( (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))) (.f64 i y))
(+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)))
(/.f64 (-.f64 (pow.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (pow.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (+.f64 #s(approx (+ ( (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)))
(-.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)) (.f64 (neg.f64 (-.f64 b #s(literal 1/2 binary64))) (log.f64 c)))
(+.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 #s(approx (+ ( (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)))
(+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (+.f64 t #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) (+.f64 a (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (-.f64 (pow.f64 (+.f64 t #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) #s(literal 2 binary64)) (.f64 a a)) (-.f64 (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) a))
(/.f64 (+.f64 (pow.f64 (+.f64 t #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 t #s(approx (+ ( (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (+.f64 t #s(approx (+ ( (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) a))))
(+.f64 a (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))))
(+.f64 (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) a)
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) #s(literal 2 binary64)) (.f64 t t)) (-.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) t))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (+.f64 (pow.f64 #s(approx (+ ( (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) #s(literal 2 binary64)) (-.f64 (.f64 t t) (.f64 #s(approx (+ ( (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) t))))
(+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)))
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) t)
#s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))
(*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)
(*.f64 z (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)))
(fma.f64 #s(literal 1 binary64) z (.f64 (.f64 (/.f64 (log.f64 y) z) x) z))
(fma.f64 z #s(literal 1 binary64) (.f64 z (.f64 (/.f64 (log.f64 y) z) x)))
(+.f64 (.f64 z #s(literal 1 binary64)) (.f64 z (*.f64 (/.f64 (log.f64 y) z) x)))
(+.f64 (.f64 #s(literal 1 binary64) z) (.f64 (*.f64 (/.f64 (log.f64 y) z) x) z))
(*.f64 (+.f64 (pow.f64 x #s(literal -1 binary64)) (/.f64 (log.f64 y) z)) x)
(*.f64 x (+.f64 (pow.f64 x #s(literal -1 binary64)) (/.f64 (log.f64 y) z)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64))) (-.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 y) z) x)))
(/.f64 (-.f64 (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) #s(literal 1 binary64)) (-.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64)))
(/.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 y) z) x)))))
(/.f64 (+.f64 (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 3 binary64)) #s(literal 1 binary64)) (+.f64 (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64)))))
(fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64))
(fma.f64 x (pow.f64 x #s(literal -1 binary64)) (*.f64 (/.f64 (log.f64 y) z) x))
(fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64))
(+.f64 (.f64 x (pow.f64 x #s(literal -1 binary64))) (.f64 (/.f64 (log.f64 y) z) x))
(+.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) (*.f64 (/.f64 (log.f64 y) z) x))
x
(/.f64 (neg.f64 (log.f64 y)) (neg.f64 z))
(/.f64 (log.f64 y) z)
(log.f64 y)
y
z
#s(literal 1 binary64)
t
a
(*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(log.f64 (pow.f64 c (-.f64 b #s(literal 1/2 binary64))))
(/.f64 (-.f64 (*.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64)))
(/.f64 (-.f64 (pow.f64 b #s(literal 3 binary64)) #s(literal 1/8 binary64)) (fma.f64 b b (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
(*.f64 i y)
(*.f64 y i)
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
(/.f64 (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) #s(literal 2 binary64)) (pow.f64 (.f64 i y) #s(literal 2 binary64))) (-.f64 #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 i y)))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) #s(literal 3 binary64)) (pow.f64 (.f64 i y) #s(literal 3 binary64))) (fma.f64 #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) a) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 i y)))))
(fma.f64 i y #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 (neg.f64 y) i))
(+.f64 (.f64 i y) #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 i y))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a)
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)) #s(literal 2 binary64)) (pow.f64 (.f64 i y) #s(literal 2 binary64))) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ ( x (log y)) z) t) t) a)) (*.f64 i y)))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)) #s(literal 3 binary64)) (pow.f64 (.f64 i y) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ ( x (log y)) z) t) t) a)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)) (*.f64 i y)))))
(fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
(-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)) (*.f64 (neg.f64 y) i))
(+.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ ( x (log y)) z) t) t) a)))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)) (*.f64 i y))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)))
(/.f64 (-.f64 (pow.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (+.f64 #s(approx (+ (+ ( x (log y)) z) t) t) a) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (pow.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 #s(approx (+ (+ ( x (log y)) z) t) t) a) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a))
(-.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (*.f64 (neg.f64 (-.f64 b #s(literal 1/2 binary64))) (log.f64 c)))
(+.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 #s(approx (+ (+ ( x (log y)) z) t) t) a))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) (+.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (+ (* x (log y)) z) t) t) #s(literal 2 binary64)) (.f64 a a)) (-.f64 #s(approx (+ (+ ( x (log y)) z) t) t) a))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (+ (* x (log y)) z) t) t) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (fma.f64 #s(approx (+ (+ (* x (log y)) z) t) t) #s(approx (+ (+ (* x (log y)) z) t) t) (-.f64 (.f64 a a) (.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a))))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)
(+.f64 a #s(approx (+ (+ (* x (log y)) z) t) t))
#s(approx (+ (+ (* x (log y)) z) t) t)
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)) #s(literal 2 binary64)) (pow.f64 (.f64 i y) #s(literal 2 binary64))) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)) (.f64 i y)))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)) #s(literal 3 binary64)) (pow.f64 (.f64 i y) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ ( x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)) (.f64 i y)))))
(fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)))
(-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)) (.f64 (neg.f64 y) i))
(+.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ ( x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)) (.f64 i y))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)))
(/.f64 (-.f64 (pow.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (pow.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (+.f64 #s(approx (+ (+ ( x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a))
(-.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) (.f64 (neg.f64 (-.f64 b #s(literal 1/2 binary64))) (log.f64 c)))
(+.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 #s(approx (+ (+ ( x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) (+.f64 a (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) #s(literal 2 binary64)) (.f64 a a)) (-.f64 #s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (+.f64 (pow.f64 #s(approx (+ (+ ( x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 #s(approx (+ (+ ( x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a))))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a)
(+.f64 a #s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t))
(*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)
(*.f64 t (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)))
(fma.f64 t #s(literal 1 binary64) (*.f64 t (/.f64 (fma.f64 (log.f64 y) x z) t)))
(fma.f64 #s(literal 1 binary64) t (*.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) t))
(+.f64 (.f64 #s(literal 1 binary64) t) (.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) t))
(+.f64 (.f64 t #s(literal 1 binary64)) (.f64 t (/.f64 (fma.f64 (log.f64 y) x z) t)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 2 binary64))) (-.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x z) t)))
(/.f64 (-.f64 (pow.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 2 binary64)) #s(literal 1 binary64)) (-.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)))
(/.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 2 binary64)) (*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x z) t)))))
(/.f64 (+.f64 (pow.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 3 binary64)) #s(literal 1 binary64)) (+.f64 (pow.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (*.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)))))
(+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64))
(+.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) (/.f64 (*.f64 (log.f64 y) x) t))
(+.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x z) t))
(/.f64 (-.f64 (pow.f64 (/.f64 z t) #s(literal 2 binary64)) (pow.f64 (/.f64 (.f64 (log.f64 y) x) t) #s(literal 2 binary64))) (-.f64 (/.f64 z t) (/.f64 (.f64 (log.f64 y) x) t)))
(/.f64 (+.f64 (pow.f64 (/.f64 z t) #s(literal 3 binary64)) (pow.f64 (/.f64 (.f64 (log.f64 y) x) t) #s(literal 3 binary64))) (+.f64 (pow.f64 (/.f64 z t) #s(literal 2 binary64)) (-.f64 (pow.f64 (/.f64 (.f64 (log.f64 y) x) t) #s(literal 2 binary64)) (.f64 (/.f64 z t) (/.f64 (.f64 (log.f64 y) x) t)))))
(/.f64 (neg.f64 (fma.f64 (log.f64 y) x z)) (neg.f64 t))
(/.f64 (fma.f64 t z (.f64 t (.f64 (log.f64 y) x))) (*.f64 t t))
(/.f64 (fma.f64 (log.f64 y) x z) t)
(fma.f64 x (/.f64 (log.f64 y) t) (/.f64 z t))
(+.f64 (/.f64 (*.f64 (log.f64 y) x) t) (/.f64 z t))
(+.f64 (/.f64 z t) (/.f64 (*.f64 (log.f64 y) x) t))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z z)) (-.f64 (*.f64 (log.f64 y) x) z))
(/.f64 (-.f64 (.f64 z z) (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64))) (-.f64 z (*.f64 (log.f64 y) x)))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (.f64 z z) (.f64 (*.f64 (log.f64 y) x) z))))
(/.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z (.f64 (log.f64 y) x)))))
(fma.f64 (log.f64 y) x z)
(fma.f64 x (log.f64 y) z)
(-.f64 z (*.f64 (neg.f64 x) (log.f64 y)))
(+.f64 z (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 t z) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)))
#s(approx (+ (+ (* x (log y)) z) t) (+.f64 t z))
#s(approx (+ (+ (* x (log y)) z) t) (fma.f64 (log.f64 y) x (+.f64 t z)))
#s(approx (+ (* (log y) x) z) z)
#s(approx (+ (* (log y) x) z) (fma.f64 (log.f64 y) x z))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) z)
#s(approx (* (+ (* x (/ (log y) z)) 1) z) (fma.f64 (log.f64 y) x z))
#s(approx (+ (* x (/ (log y) z)) 1) #s(literal 1 binary64))
#s(approx (+ (* x (/ (log y) z)) 1) (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)))
#s(approx x x)
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) t (*.f64 (log.f64 y) x)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (+.f64 (/.f64 z t) #s(literal 1 binary64)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)))
#s(approx (/ (+ (* (log y) x) z) t) (/.f64 z t))
#s(approx (/ (+ (* (log y) x) z) t) (/.f64 (fma.f64 (log.f64 y) x z) t))
#s(approx (+ (* (log y) x) z) z)
#s(approx (+ (* (log y) x) z) (fma.f64 (log.f64 y) x z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (/.f64 (+.f64 t z) x) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) x))) x))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t z) a) x) (log.f64 y)) x))
#s(approx (+ (+ (* x (log y)) z) t) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (+.f64 t z) x) (log.f64 y)) x))
#s(approx (+ (* (log y) x) z) (*.f64 (log.f64 y) x))
#s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) (*.f64 (log.f64 y) x))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
#s(approx (+ (* x (/ (log y) z)) 1) (*.f64 (/.f64 (log.f64 y) z) x))
#s(approx (+ (* x (/ (log y) z)) 1) (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (log.f64 y) x))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (fma.f64 t (/.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) x) (log.f64 y)) x))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (/.f64 (*.f64 (log.f64 y) x) t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (*.f64 (+.f64 (/.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) x) (/.f64 (log.f64 y) t)) x))
#s(approx (/ (+ (* (log y) x) z) t) (/.f64 (*.f64 (log.f64 y) x) t))
#s(approx (/ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (log.f64 y) t) (/.f64 (/.f64 z t) x)) x))
#s(approx (+ (* (log y) x) z) (*.f64 (log.f64 y) x))
#s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) z)) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* x (log y)) z) t) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 t z) x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log y) x) z) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 z x) (neg.f64 (log.f64 y))) x)))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 z x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* x (/ (log y) z)) 1) (neg.f64 (*.f64 (-.f64 (/.f64 (neg.f64 (log.f64 y)) z) (pow.f64 x #s(literal -1 binary64))) x)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (neg.f64 (.f64 (.f64 #s(literal -1 binary64) (fma.f64 t (/.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) x) (log.f64 y))) x)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) x) #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 y)) t)) x)))
#s(approx (/ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (log.f64 y) t) (neg.f64 (/.f64 (/.f64 z t) x))) x)))
#s(approx (+ (* (log y) x) z) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 z x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))
#s(approx (/ (log y) z) (/.f64 (log.f64 y) z))
#s(approx (log y) (log.f64 y))
#s(approx y y)
#s(approx (* y i) (*.f64 i y))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t))
#s(approx (/ (+ (* (log y) x) z) t) (/.f64 (fma.f64 (log.f64 y) x z) t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 a t) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z)))
#s(approx (+ (+ (* x (log y)) z) t) (+.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z) t))
#s(approx (+ (* (log y) x) z) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) (.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) z)) #s(literal -1 binary64) #s(literal 1 binary64)) z))
#s(approx (+ (* x (/ (log y) z)) 1) (fma.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z)) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (/ (log y) z) (neg.f64 (/.f64 (neg.f64 (log.f64 y)) z)))
#s(approx (log y) (neg.f64 (neg.f64 (log.f64 y))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (.f64 (+.f64 (/.f64 (fma.f64 (.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z) t) #s(literal 1 binary64)) t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (+.f64 (/.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z) t) #s(literal 1 binary64)))
#s(approx (/ (+ (* (log y) x) z) t) (/.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z) t))
#s(approx (+ (* (log y) x) z) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (neg.f64 y) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) y) #s(literal -1 binary64) (neg.f64 i))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 a t) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z)))
#s(approx (+ (+ (* x (log y)) z) t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t))
#s(approx (+ (* (log y) x) z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) (*.f64 (fma.f64 x (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) z) #s(literal 1 binary64)) z))
#s(approx (+ (* x (/ (log y) z)) 1) (fma.f64 x (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) z) #s(literal 1 binary64)))
#s(approx (/ (log y) z) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) z))
#s(approx (log y) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (+.f64 (/.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t) #s(literal 1 binary64)) t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (+.f64 (/.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t) #s(literal 1 binary64)))
#s(approx (/ (+ (* (log y) x) z) t) (/.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t))
#s(approx (+ (* (log y) x) z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (fma.f64 (log.f64 y) x t) a))
#s(approx (+ (+ (* x (log y)) z) t) (fma.f64 (log.f64 y) x t))
#s(approx (+ (* x (/ (log y) z)) 1) (/.f64 (fma.f64 (log.f64 y) x z) z))
#s(approx z z)
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) t z))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) z)) (/.f64 t z))) z))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z)
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x t) z) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) z))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) z)
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) #s(literal 1 binary64)) z))
#s(approx (+ (+ (* x (log y)) z) t) z)
#s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x t) z) #s(literal 1 binary64)) z))
#s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z) #s(literal 1 binary64)) z))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (/.f64 z t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (*.f64 (+.f64 (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z) (pow.f64 t #s(literal -1 binary64))) z))
#s(approx (/ (+ (* (log y) x) z) t) (*.f64 (fma.f64 (/.f64 x t) (/.f64 (log.f64 y) z) (pow.f64 t #s(literal -1 binary64))) z))
#s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* x (log y)) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x t) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* (log y) x) z) (neg.f64 (.f64 (-.f64 (neg.f64 (.f64 (/.f64 (log.f64 y) z) x)) #s(literal 1 binary64)) z)))
#s(approx (* (+ (* x (/ (log y) z)) 1) z) (neg.f64 (.f64 (-.f64 (neg.f64 (.f64 (/.f64 (log.f64 y) z) x)) #s(literal 1 binary64)) z)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) t) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z)) (pow.f64 t #s(literal -1 binary64))) z)))
#s(approx (/ (+ (* (log y) x) z) t) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (/.f64 (.f64 (log.f64 y) x) t) z)) (pow.f64 t #s(literal -1 binary64))) z)))
#s(approx (+ (* (log y) x) z) (neg.f64 (.f64 (-.f64 (neg.f64 (.f64 (/.f64 (log.f64 y) z) x)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (fma.f64 (log.f64 y) x z) a))
#s(approx (+ (+ (* x (log y)) z) t) (fma.f64 (log.f64 y) x z))
#s(approx t t)
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 (log.f64 y) x z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 (log.f64 y) x (+.f64 t z)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (/.f64 (fma.f64 (log.f64 y) x z) t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (/.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (+.f64 (fma.f64 i (/.f64 y t) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t)) (/.f64 z t))) t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t)
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) t)
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) a) t) #s(literal 1 binary64)) t))
#s(approx (+ (+ (* x (log y)) z) t) t)
#s(approx (+ (+ (* x (log y)) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(literal 1 binary64))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) a) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* x (log y)) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x z) t)) #s(literal 1 binary64)) t)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x z) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (fma.f64 (log.f64 y) x (+.f64 t z)))
#s(approx a a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t a)) (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) a)) (/.f64 z a))) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a)
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t a)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) a)
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a) #s(literal 1 binary64)) a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 i y (*.f64 (log.f64 y) x))) z)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x)) z)))
#s(approx (* (- b 1/2) (log c)) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b)))
#s(approx (- b 1/2) #s(literal -1/2 binary64))
#s(approx (- b 1/2) (-.f64 b #s(literal 1/2 binary64)))
#s(approx b b)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 i y (.f64 (log.f64 y) x)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) b) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) b))
#s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))
#s(approx (- b 1/2) b)
#s(approx (- b 1/2) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 #s(literal 1/2 binary64) b)) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (.f64 (log.f64 y) x))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 (log.f64 y) x)) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (* (- b 1/2) (log c)) (neg.f64 (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal 1/2 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (- b 1/2) (neg.f64 (*.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) b) #s(literal 1 binary64)) b)))
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (log c) (log.f64 c))
#s(approx c c)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y (*.f64 (log.f64 y) x)))) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) a))
#s(approx (* (- b 1/2) (log c)) (*.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (log c) (neg.f64 (neg.f64 (log.f64 c))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 i y (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (log c) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx i i)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (/.f64 t i) (/.f64 z i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i))) i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))

eval44.0ms (0.7%)

Memory: 17.4MiB live, 109.3MiB allocated; 10ms collecting garbage
Compiler: Compiled 13 480 to 1 877 computations (86.1% saved)

prune20.0ms (0.3%)

Memory

3.3MiB live, 50.6MiB allocated; 2ms collecting garbage

Pruning

24 alts after pruning (23 fresh and 1 done)

	Pruned	Kept	Total
New	341	7	348
Fresh	4	16	20
Picked	4	1	5
Done	0	0	0
Total	349	24	373

Accuracy

100.0%

Counts

373 → 24

Alt Table

Click to see full alt table

Status	Accuracy	Program
	57.3%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
▶	91.8%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))))
▶	42.1%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
▶	86.5%	(+.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
	63.3%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 (log.f64 y) x) t)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
	76.6%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (.f64 (fma.f64 t (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z) #s(literal 1 binary64)) z))) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
▶	80.4%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
	54.8%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (log.f64 y) x)) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
	60.9%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
	81.2%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) (*.f64 y i))
	78.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t a)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a)) (*.f64 y i))
	67.1%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t)) (*.f64 y i))
	35.4%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
	24.7%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
	78.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
	69.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
	66.2%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))
	19.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
	14.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
	23.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
	72.2%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
	24.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
▶	3.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
✓	20.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 1 543 to 1 255 computations (18.7% saved)

series334.0ms (5.3%)

Memory

-10.7MiB live, 426.3MiB allocated; 41ms collecting garbage

Counts

39 → 384

Calls

Call 1

Inputs
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))))
y
i
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)))
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))
#s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))
(*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)
(fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64))
(/.f64 (log.f64 y) z)
(log.f64 y)
z
x
#s(literal 1 binary64)
(+.f64 t a)
t
a
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a)
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)
#s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(*.f64 y i)
(+.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a)
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t)
#s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(+.f64 (/.f64 z x) (log.f64 y))
(/.f64 z x)

Outputs
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 z))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 z))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 1))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (+ 1 (/ (* x (log y)) z))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ z t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ (* t (+ 1 (/ z t))) (* x (log y)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 z))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (/ z x)))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (/ (+ z (* x (log y))) x)))
#s(approx (/ z x) #s(hole binary64 (/ z x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ (log y) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (+ (log y) (/ (* t (+ 1 (/ z t))) x)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (log y)))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (log y) (/ z x))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (log y) z)) (/ 1 x))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* t (+ 1 (/ z t))) x)))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx y #s(hole binary64 y))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (/ (log y) z) #s(hole binary64 (/ (log y) z)))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (* y i) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 y)))))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* z (+ 1 (* -1 (/ (* x (log (/ 1 y))) z))))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (+ 1 (* -1 (/ (* x (log (/ 1 y))) z)))))
#s(approx (/ (log y) z) #s(hole binary64 (* -1 (/ (log (/ 1 y)) z))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) t)) (/ z t))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (* -1 (log (/ 1 y))) (/ z x)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (* -1 (log (/ 1 y))) (/ z x))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* z (+ 1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (+ 1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z))))
#s(approx (/ (log y) z) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 y)))) z)))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (/ z x))))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 y))) (/ z x)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (/ (+ z (* x (log y))) z)))
#s(approx z #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ (* x (log y)) t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* t (+ 1 (/ (* x (log y)) t))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* z (+ 1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (* z (+ (/ 1 x) (/ (log y) z)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (log y) z)) (/ 1 x))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ t a) #s(hole binary64 a))
#s(approx (+ t a) #s(hole binary64 (+ a t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 t))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ t a) #s(hole binary64 t))
#s(approx (+ t a) #s(hole binary64 (* t (+ 1 (/ a t)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ t a) #s(hole binary64 (* -1 (* t (- (* -1 (/ a t)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 a))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ t a) #s(hole binary64 (* a (+ 1 (/ t a)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ t a) #s(hole binary64 (* -1 (* a (- (* -1 (/ t a)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (- b 1/2) #s(hole binary64 -1/2))
#s(approx (- b 1/2) #s(hole binary64 (- b 1/2)))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (- b 1/2) #s(hole binary64 b))
#s(approx (- b 1/2) #s(hole binary64 (* b (- 1 (* 1/2 (/ 1 b))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (- b 1/2) #s(hole binary64 (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (log c) #s(hole binary64 (log c)))
#s(approx c #s(hole binary64 c))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (log c) #s(hole binary64 (* -1 (log (/ 1 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* (log (/ 1 c)) (- b 1/2)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (log c) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 c))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx i #s(hole binary64 i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))

Calls

24 calls:

Time	Variable		Point	Expression
63.0ms	y	@	-inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) y i (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (log c) c (- b 1/2) b 1/2 (+ (+ (* (log y) x) z) (+ t a)) (+ (* (log y) x) z) (* (+ (* (/ (log y) z) x) 1) z) (+ (* (/ (log y) z) x) 1) (/ (log y) z) (log y) z x 1 (+ t a) t a (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (* (- b 1/2) (log c)) (* y i) (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* (log y) x) z) t) a) (+ (+ (* (log y) x) z) t) (+ (* (log y) x) z) (* (+ (/ z x) (log y)) x) (+ (/ z x) (log y)) (/ z x))
43.0ms	b	@	inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) y i (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (log c) c (- b 1/2) b 1/2 (+ (+ (* (log y) x) z) (+ t a)) (+ (* (log y) x) z) (* (+ (* (/ (log y) z) x) 1) z) (+ (* (/ (log y) z) x) 1) (/ (log y) z) (log y) z x 1 (+ t a) t a (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (* (- b 1/2) (log c)) (* y i) (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* (log y) x) z) t) a) (+ (+ (* (log y) x) z) t) (+ (* (log y) x) z) (* (+ (/ z x) (log y)) x) (+ (/ z x) (log y)) (/ z x))
36.0ms	c	@	inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) y i (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (log c) c (- b 1/2) b 1/2 (+ (+ (* (log y) x) z) (+ t a)) (+ (* (log y) x) z) (* (+ (* (/ (log y) z) x) 1) z) (+ (* (/ (log y) z) x) 1) (/ (log y) z) (log y) z x 1 (+ t a) t a (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (* (- b 1/2) (log c)) (* y i) (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* (log y) x) z) t) a) (+ (+ (* (log y) x) z) t) (+ (* (log y) x) z) (* (+ (/ z x) (log y)) x) (+ (/ z x) (log y)) (/ z x))
32.0ms	z	@	inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) y i (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (log c) c (- b 1/2) b 1/2 (+ (+ (* (log y) x) z) (+ t a)) (+ (* (log y) x) z) (* (+ (* (/ (log y) z) x) 1) z) (+ (* (/ (log y) z) x) 1) (/ (log y) z) (log y) z x 1 (+ t a) t a (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (* (- b 1/2) (log c)) (* y i) (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* (log y) x) z) t) a) (+ (+ (* (log y) x) z) t) (+ (* (log y) x) z) (* (+ (/ z x) (log y)) x) (+ (/ z x) (log y)) (/ z x))
19.0ms	y	@	inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) y i (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (log c) c (- b 1/2) b 1/2 (+ (+ (* (log y) x) z) (+ t a)) (+ (* (log y) x) z) (* (+ (* (/ (log y) z) x) 1) z) (+ (* (/ (log y) z) x) 1) (/ (log y) z) (log y) z x 1 (+ t a) t a (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (* (- b 1/2) (log c)) (* y i) (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* (log y) x) z) t) a) (+ (+ (* (log y) x) z) t) (+ (* (log y) x) z) (* (+ (/ z x) (log y)) x) (+ (/ z x) (log y)) (/ z x))

rewrite269.0ms (4.3%)

Memory

10.4MiB live, 288.0MiB allocated; 23ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	876	11967
0	914	11505
1	4769	11417
0	8411	10546

Stop Event

1×	iter-limit
1×	node-limit
1×	iter-limit

Counts

423 → 522

Calls

Call 1

Inputs
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))))
y
i
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a)))
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))
#s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))
(*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)
(fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64))
(/.f64 (log.f64 y) z)
(log.f64 y)
z
x
#s(literal 1 binary64)
(+.f64 t a)
t
a
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a)
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)
#s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(*.f64 y i)
(+.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a)
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t)
#s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(+.f64 (/.f64 z x) (log.f64 y))
(/.f64 z x)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 z))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 z))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 1))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (+ 1 (/ (* x (log y)) z))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ z t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ (* t (+ 1 (/ z t))) (* x (log y)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 z))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (/ z x)))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (/ (+ z (* x (log y))) x)))
#s(approx (/ z x) #s(hole binary64 (/ z x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (/ (* x (log y)) z)))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (* x (+ (/ 1 x) (/ (log y) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (+ (log y) (/ (* t (+ 1 (/ z t))) x)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (log y)))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (log y) (/ z x))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (* -1 (* x (- (* -1 (/ (log y) z)) (/ 1 x))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* t (+ 1 (/ z t))) x)))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx y #s(hole binary64 y))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (/ (log y) z) #s(hole binary64 (/ (log y) z)))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (* y i) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 y)))))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* z (+ 1 (* -1 (/ (* x (log (/ 1 y))) z))))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (+ 1 (* -1 (/ (* x (log (/ 1 y))) z)))))
#s(approx (/ (log y) z) #s(hole binary64 (* -1 (/ (log (/ 1 y)) z))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) t)) (/ z t))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (* -1 (log (/ 1 y))) (/ z x)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (* -1 (log (/ 1 y))) (/ z x))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* z (+ 1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z)))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (+ 1 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) z))))
#s(approx (/ (log y) z) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 y)))) z)))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (/ z x))))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 y))) (/ z x)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (* (/ (log y) z) x) 1) #s(hole binary64 (/ (+ z (* x (log y))) z)))
#s(approx z #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ (* x (log y)) t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* t (+ 1 (/ (* x (log y)) t))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* z (+ 1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (* z (+ (/ 1 x) (/ (log y) z)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (log y) z)) (/ 1 x))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ t a) #s(hole binary64 a))
#s(approx (+ t a) #s(hole binary64 (+ a t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 t))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ t a) #s(hole binary64 t))
#s(approx (+ t a) #s(hole binary64 (* t (+ 1 (/ a t)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ t a) #s(hole binary64 (* -1 (* t (- (* -1 (/ a t)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 a))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ t a) #s(hole binary64 (* a (+ 1 (/ t a)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ t a) #s(hole binary64 (* -1 (* a (- (* -1 (/ t a)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (- b 1/2) #s(hole binary64 -1/2))
#s(approx (- b 1/2) #s(hole binary64 (- b 1/2)))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (- b 1/2) #s(hole binary64 b))
#s(approx (- b 1/2) #s(hole binary64 (* b (- 1 (* 1/2 (/ 1 b))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (- b 1/2) #s(hole binary64 (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (log c) #s(hole binary64 (log c)))
#s(approx c #s(hole binary64 c))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (log c) #s(hole binary64 (* -1 (log (/ 1 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* (log (/ 1 c)) (- b 1/2)))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (log c) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 c))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx i #s(hole binary64 i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (+ (+ (+ (+ (* (log y) x) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))

Outputs
(/.f64 (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) #s(approx (+ ( (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)))) #s(literal 2 binary64))) (-.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))))))
(/.f64 (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) #s(approx (+ ( (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)))) #s(literal 2 binary64)) (.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) #s(approx (+ ( (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))))))))
(fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)))))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) (+.f64 (+.f64 a t) #s(approx (+ ( (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))))
(+.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) #s(approx (+ ( (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)))))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)))) (.f64 i y))
y
i
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (+.f64 (+.f64 a t) #s(approx (+ ( (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) #s(literal 2 binary64))) (-.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (+.f64 (+.f64 a t) #s(approx (+ ( (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 a t) #s(approx (+ ( (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) (+.f64 a t))
(+.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 a t) #s(approx (+ ( (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))))
(+.f64 (+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(log.f64 c)
c
(/.f64 (-.f64 (*.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64)))
(/.f64 (-.f64 (pow.f64 b #s(literal 3 binary64)) #s(literal 1/8 binary64)) (fma.f64 b b (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(/.f64 (-.f64 (pow.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) #s(literal 2 binary64)) (pow.f64 (+.f64 a t) #s(literal 2 binary64))) (-.f64 #s(approx (+ ( (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 a t)))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (* (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) #s(literal 3 binary64)) (pow.f64 (+.f64 a t) #s(literal 3 binary64))) (+.f64 (pow.f64 #s(approx (+ ( (log y) x) z) (.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 a t) #s(literal 2 binary64)) (.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 a t)))))
(+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) t) a)
(+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)))
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 a t))
#s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))
(*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)
(*.f64 z (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)))
(fma.f64 #s(literal 1 binary64) z (.f64 (.f64 (/.f64 (log.f64 y) z) x) z))
(fma.f64 z #s(literal 1 binary64) (.f64 z (.f64 (/.f64 (log.f64 y) z) x)))
(+.f64 (.f64 z #s(literal 1 binary64)) (.f64 z (*.f64 (/.f64 (log.f64 y) z) x)))
(+.f64 (.f64 #s(literal 1 binary64) z) (.f64 (*.f64 (/.f64 (log.f64 y) z) x) z))
(*.f64 (+.f64 (pow.f64 x #s(literal -1 binary64)) (/.f64 (log.f64 y) z)) x)
(*.f64 x (+.f64 (pow.f64 x #s(literal -1 binary64)) (/.f64 (log.f64 y) z)))
(/.f64 (-.f64 (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) #s(literal 1 binary64)) (-.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64)))
(/.f64 (-.f64 #s(literal 1 binary64) (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64))) (-.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 y) z) x)))
(/.f64 (+.f64 (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 3 binary64)) #s(literal 1 binary64)) (+.f64 (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (-.f64 #s(literal 1 binary64) (.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64)))))
(/.f64 (+.f64 #s(literal 1 binary64) (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 3 binary64))) (+.f64 #s(literal 1 binary64) (-.f64 (pow.f64 (.f64 (/.f64 (log.f64 y) z) x) #s(literal 2 binary64)) (.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 y) z) x)))))
(fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64))
(fma.f64 x (pow.f64 x #s(literal -1 binary64)) (*.f64 (/.f64 (log.f64 y) z) x))
(fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64))
(+.f64 (.f64 x (pow.f64 x #s(literal -1 binary64))) (.f64 (/.f64 (log.f64 y) z) x))
(+.f64 (*.f64 (/.f64 (log.f64 y) z) x) #s(literal 1 binary64))
(+.f64 #s(literal 1 binary64) (*.f64 (/.f64 (log.f64 y) z) x))
(/.f64 (neg.f64 (log.f64 y)) (neg.f64 z))
(/.f64 (log.f64 y) z)
(log.f64 y)
z
x
#s(literal 1 binary64)
(/.f64 (-.f64 (.f64 t t) (.f64 a a)) (-.f64 t a))
(/.f64 (-.f64 (.f64 a a) (.f64 t t)) (-.f64 a t))
(/.f64 (+.f64 (pow.f64 t #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (fma.f64 t t (-.f64 (.f64 a a) (.f64 t a))))
(/.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))))
(+.f64 a t)
(+.f64 t a)
t
a
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) t)
(/.f64 (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (pow.f64 #s(approx (+ ( (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a) #s(literal 2 binary64))) (-.f64 (.f64 i y) #s(approx (+ ( (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a)))
(/.f64 (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 #s(approx (+ ( (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 #s(approx (+ ( (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a) #s(literal 2 binary64)) (.f64 (.f64 i y) #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a)))))
(fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a))
(+.f64 #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a) (*.f64 i y))
(+.f64 (.f64 i y) #s(approx (+ ( (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a)
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)) #s(literal 2 binary64)) (pow.f64 (.f64 i y) #s(literal 2 binary64))) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)) (*.f64 i y)))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)) #s(literal 3 binary64)) (pow.f64 (.f64 i y) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)) (*.f64 i y)))))
(fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)) (*.f64 (neg.f64 y) i))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)) (*.f64 i y))
(+.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)))
(+.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(/.f64 (-.f64 (pow.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (pow.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))
(-.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (*.f64 (neg.f64 (-.f64 b #s(literal 1/2 binary64))) (log.f64 c)))
(+.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))
(+.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) (+.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (-.f64 (.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) (.f64 a a)) (-.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (fma.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) (-.f64 (.f64 a a) (.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))))
(+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)
(+.f64 a #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)))
#s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)
(*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(log.f64 (pow.f64 c (-.f64 b #s(literal 1/2 binary64))))
(*.f64 i y)
(*.f64 y i)
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))) #s(literal 2 binary64)) (pow.f64 (.f64 i y) #s(literal 2 binary64))) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))) (.f64 i y)))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))) #s(literal 3 binary64)) (pow.f64 (.f64 i y) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ ( (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))) (.f64 i y)))))
(fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))))
(-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))) (.f64 (neg.f64 y) i))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))) (.f64 i y))
(+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)))
(+.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ ( (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))))
(/.f64 (-.f64 (pow.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (pow.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (+.f64 #s(approx (+ ( (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)))
(-.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)) (.f64 (neg.f64 (-.f64 b #s(literal 1/2 binary64))) (log.f64 c)))
(+.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 #s(approx (+ ( (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)))
(+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) (+.f64 a (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (-.f64 (pow.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) #s(literal 2 binary64)) (.f64 a a)) (-.f64 (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a))
(/.f64 (+.f64 (pow.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 #s(approx (+ ( (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (+.f64 #s(approx (+ ( (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a))))
(+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a)
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))
(+.f64 a (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(literal 2 binary64)) (.f64 t t)) (-.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (+.f64 (pow.f64 #s(approx (+ ( (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(literal 2 binary64)) (-.f64 (.f64 t t) (.f64 #s(approx (+ ( (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t))))
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t)
(+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)))
#s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(*.f64 x (+.f64 (/.f64 z x) (log.f64 y)))
(fma.f64 x (log.f64 y) (*.f64 (/.f64 z x) x))
(fma.f64 x (log.f64 y) (*.f64 x (/.f64 z x)))
(fma.f64 (log.f64 y) x (*.f64 (/.f64 z x) x))
(fma.f64 (log.f64 y) x (*.f64 x (/.f64 z x)))
(+.f64 (.f64 x (log.f64 y)) (.f64 (/.f64 z x) x))
(+.f64 (.f64 x (log.f64 y)) (.f64 x (/.f64 z x)))
(/.f64 (-.f64 (pow.f64 (/.f64 z x) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64))) (-.f64 (/.f64 z x) (log.f64 y)))
(/.f64 (-.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (pow.f64 (/.f64 z x) #s(literal 2 binary64))) (-.f64 (log.f64 y) (/.f64 z x)))
(/.f64 (+.f64 (pow.f64 (/.f64 z x) #s(literal 3 binary64)) (pow.f64 (log.f64 y) #s(literal 3 binary64))) (+.f64 (pow.f64 (/.f64 z x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (*.f64 (/.f64 z x) (log.f64 y)))))
(/.f64 (+.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 (/.f64 z x) #s(literal 3 binary64))) (fma.f64 (log.f64 y) (log.f64 y) (-.f64 (pow.f64 (/.f64 z x) #s(literal 2 binary64)) (*.f64 (log.f64 y) (/.f64 z x)))))
(+.f64 (/.f64 z x) (log.f64 y))
(+.f64 (log.f64 y) (/.f64 z x))
(/.f64 (neg.f64 z) (neg.f64 x))
(/.f64 z x)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (+.f64 t z) a))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a))
#s(approx (+ (* (log y) x) z) z)
#s(approx (+ (* (log y) x) z) (fma.f64 x (log.f64 y) z))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) z)
#s(approx (* (+ (* (/ (log y) z) x) 1) z) (fma.f64 x (log.f64 y) z))
#s(approx (+ (* (/ (log y) z) x) 1) #s(literal 1 binary64))
#s(approx (+ (* (/ (log y) z) x) 1) (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)))
#s(approx x x)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (+.f64 t z) a))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 t z))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) t (*.f64 x (log.f64 y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (+.f64 t z) a))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 t z))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx (* (+ (/ z x) (log y)) x) z)
#s(approx (* (+ (/ z x) (log y)) x) (fma.f64 x (log.f64 y) z))
#s(approx (+ (/ z x) (log y)) (/.f64 z x))
#s(approx (+ (/ z x) (log y)) (/.f64 (fma.f64 x (log.f64 y) z) x))
#s(approx (/ z x) (/.f64 z x))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 x (log.f64 y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (/.f64 (+.f64 t z) x) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) x))) x))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 x (log.f64 y)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t z) a) x) (log.f64 y)) x))
#s(approx (+ (* (log y) x) z) (*.f64 x (log.f64 y)))
#s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) (*.f64 x (log.f64 y)))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
#s(approx (+ (* (/ (log y) z) x) 1) (*.f64 (/.f64 (log.f64 y) z) x))
#s(approx (+ (* (/ (log y) z) x) 1) (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 x (log.f64 y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (/.f64 (+.f64 t z) x) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) x))) x))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 x (log.f64 y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (/.f64 (+.f64 t z) x) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) x))) x))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 x (log.f64 y)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t z) a) x) (log.f64 y)) x))
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 x (log.f64 y)))
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (+.f64 t z) x) (log.f64 y)) x))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 x (log.f64 y)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (fma.f64 t (/.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) x) (log.f64 y)) x))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 x (log.f64 y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (/.f64 (+.f64 t z) x) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) x))) x))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 x (log.f64 y)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t z) a) x) (log.f64 y)) x))
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 x (log.f64 y)))
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (+.f64 t z) x) (log.f64 y)) x))
#s(approx (* (+ (/ z x) (log y)) x) (*.f64 x (log.f64 y)))
#s(approx (* (+ (/ z x) (log y)) x) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
#s(approx (+ (/ z x) (log y)) (log.f64 y))
#s(approx (+ (/ z x) (log y)) (+.f64 (/.f64 z x) (log.f64 y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) z)) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log y) x) z) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 z x) (neg.f64 (log.f64 y))) x)))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 z x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (/ (log y) z) x) 1) (neg.f64 (*.f64 (-.f64 (/.f64 (neg.f64 (log.f64 y)) z) (pow.f64 x #s(literal -1 binary64))) x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) z)) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) z)) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 t z) x) (neg.f64 (log.f64 y))) x)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (neg.f64 (.f64 (.f64 #s(literal -1 binary64) (fma.f64 t (/.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) x) (log.f64 y))) x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) z)) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 t z) x) (neg.f64 (log.f64 y))) x)))
#s(approx (* (+ (/ z x) (log y)) x) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 z x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx y y)
#s(approx (* (+ (* (/ (log y) z) x) 1) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))
#s(approx (/ (log y) z) (/.f64 (log.f64 y) z))
#s(approx (log y) (log.f64 y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) #s(literal 1 binary64)) t))
#s(approx (* y i) (*.f64 i y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 i y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (+.f64 a t) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z)))
#s(approx (+ (* (log y) x) z) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) (.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) z)) #s(literal -1 binary64) #s(literal 1 binary64)) z))
#s(approx (+ (* (/ (log y) z) x) 1) (fma.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) z)) #s(literal -1 binary64) #s(literal 1 binary64)))
#s(approx (/ (log y) z) (neg.f64 (/.f64 (neg.f64 (log.f64 y)) z)))
#s(approx (log y) (neg.f64 (neg.f64 (log.f64 y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 i y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 i y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (+.f64 a t) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z)))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) t)) #s(literal -1 binary64) (/.f64 z t)) #s(literal 1 binary64)) t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 i y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (+.f64 a t) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z)))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z) t))
#s(approx (* (+ (/ z x) (log y)) x) (*.f64 (fma.f64 (neg.f64 (log.f64 y)) #s(literal -1 binary64) (/.f64 z x)) x))
#s(approx (+ (/ z x) (log y)) (fma.f64 (neg.f64 (log.f64 y)) #s(literal -1 binary64) (/.f64 z x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (neg.f64 y) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) y) #s(literal -1 binary64) (neg.f64 i))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (+.f64 a t) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z)))
#s(approx (+ (* (log y) x) z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) (*.f64 (fma.f64 x (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) z) #s(literal 1 binary64)) z))
#s(approx (+ (* (/ (log y) z) x) 1) (fma.f64 x (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) z) #s(literal 1 binary64)))
#s(approx (/ (log y) z) (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) z))
#s(approx (log y) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (neg.f64 y) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) y) #s(literal -1 binary64) (neg.f64 i))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (neg.f64 y) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) y) #s(literal -1 binary64) (neg.f64 i))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (+.f64 a t) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z)))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (+.f64 (/.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t) #s(literal 1 binary64)) t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (neg.f64 y) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) y) #s(literal -1 binary64) (neg.f64 i))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (+.f64 a t) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z)))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t))
#s(approx (* (+ (/ z x) (log y)) x) (*.f64 (+.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (/.f64 z x)) (log.f64 #s(literal -1 binary64))) x))
#s(approx (+ (/ z x) (log y)) (+.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (/.f64 z x)) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (fma.f64 x (log.f64 y) t) a))
#s(approx (+ (* (/ (log y) z) x) 1) (/.f64 (fma.f64 x (log.f64 y) z) z))
#s(approx z z)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (fma.f64 x (log.f64 y) t) a))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) t z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (fma.f64 x (log.f64 y) t) a))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) z)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) z)) (/.f64 t z))) z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) z)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) t) z) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) z))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) z)
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z) #s(literal 1 binary64)) z))
#s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) z)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) z)) (/.f64 t z))) z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) z)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) z)) (/.f64 t z))) z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) z)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) t) z) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) z))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) z)
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z) #s(literal 1 binary64)) z))
#s(approx (+ (+ (* (log y) x) z) t) z)
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) t) z) #s(literal 1 binary64)) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z) #s(literal 1 binary64)) z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) z)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) z)) (/.f64 t z))) z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) z)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) t) z) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) z))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) z)
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z) #s(literal 1 binary64)) z))
#s(approx (+ (+ (* (log y) x) z) t) z)
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) t) z) #s(literal 1 binary64)) z))
#s(approx (* (+ (/ z x) (log y)) x) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z))
#s(approx (+ (/ z x) (log y)) (*.f64 (+.f64 (pow.f64 x #s(literal -1 binary64)) (/.f64 (log.f64 y) z)) z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* (log y) x) z) (neg.f64 (.f64 (-.f64 (neg.f64 (.f64 (/.f64 (log.f64 y) z) x)) #s(literal 1 binary64)) z)))
#s(approx (* (+ (* (/ (log y) z) x) 1) z) (neg.f64 (.f64 (-.f64 (neg.f64 (.f64 (/.f64 (log.f64 y) z) x)) #s(literal 1 binary64)) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) t) z)) #s(literal 1 binary64)) z)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) t) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) t) z)) #s(literal 1 binary64)) z)))
#s(approx (* (+ (/ z x) (log y)) x) (neg.f64 (.f64 (-.f64 (neg.f64 (.f64 (/.f64 (log.f64 y) z) x)) #s(literal 1 binary64)) z)))
#s(approx (+ (/ z x) (log y)) (neg.f64 (*.f64 (-.f64 (/.f64 (neg.f64 (log.f64 y)) z) (pow.f64 x #s(literal -1 binary64))) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (fma.f64 x (log.f64 y) z) a))
#s(approx (+ t a) a)
#s(approx (+ t a) (+.f64 a t))
#s(approx t t)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (fma.f64 x (log.f64 y) z) a))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 x (log.f64 y) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (+.f64 (fma.f64 x (log.f64 y) z) a))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) t)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y t) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) t)) (/.f64 z t))) t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) t)
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t) #s(literal 1 binary64)) t))
#s(approx (+ t a) t)
#s(approx (+ t a) (*.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) t)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y t) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) t)) (/.f64 z t))) t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) t)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y t) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) t)) (/.f64 z t))) t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) t)
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t) #s(literal 1 binary64)) t))
#s(approx (+ (+ (* (log y) x) z) t) t)
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) #s(literal 1 binary64)) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) t)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y t) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) t)) (/.f64 z t))) t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) t)
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t) #s(literal 1 binary64)) t))
#s(approx (+ (+ (* (log y) x) z) t) t)
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) #s(literal 1 binary64)) t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t)) #s(literal 1 binary64)) t)))
#s(approx (+ t a) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 a t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) z) t)) #s(literal 1 binary64)) t)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) z) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) z) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx a a)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) a)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) a)) (/.f64 z a))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) a)
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a) #s(literal 1 binary64)) a))
#s(approx (+ t a) (*.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) a)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) a)) (/.f64 z a))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) a)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) a)) (/.f64 z a))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) a)
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a) #s(literal 1 binary64)) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) a)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) a)) (/.f64 z a))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) a)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) a)
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a) #s(literal 1 binary64)) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a)) #s(literal 1 binary64)) a)))
#s(approx (+ t a) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 t a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (* (log y) x) z) (+ t a)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (- b 1/2) #s(literal -1/2 binary64))
#s(approx (- b 1/2) (-.f64 b #s(literal 1/2 binary64)))
#s(approx b b)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (* (- b 1/2) (log c)) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 (log.f64 c) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (.f64 i y)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) b) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (- b 1/2) b)
#s(approx (- b 1/2) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 #s(literal 1/2 binary64) b)) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 (log.f64 c) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (.f64 i y)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 (log.f64 c) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (.f64 i y)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) b) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) b))
#s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (*.f64 (log.f64 c) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (.f64 i y)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) b) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 x (log.f64 y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (- b 1/2) (neg.f64 (*.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) b) #s(literal 1 binary64)) b)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 x (log.f64 y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (* (- b 1/2) (log c)) (neg.f64 (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal 1/2 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 x (log.f64 y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (log c) (log.f64 c))
#s(approx c c)
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 x (log.f64 y) (*.f64 i y)))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) a))
#s(approx (log c) (neg.f64 (neg.f64 (log.f64 c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 x (log.f64 y) (*.f64 i y)))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 x (log.f64 y) (*.f64 i y)))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) a))
#s(approx (* (- b 1/2) (log c)) (*.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 x (log.f64 y) (*.f64 i y)))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (log c) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx i i)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (/.f64 t i) (/.f64 z i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) i))) i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (/.f64 t i) (/.f64 z i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) i))) i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (/.f64 t i) (/.f64 z i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) i))) i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (/.f64 t i) (/.f64 z i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) i))) i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 x (log.f64 y) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))

eval50.0ms (0.8%)

Memory: 2.4MiB live, 100.2MiB allocated; 21ms collecting garbage
Compiler: Compiled 13 291 to 1 767 computations (86.7% saved)

prune24.0ms (0.4%)

Memory

24.7MiB live, 69.2MiB allocated; 3ms collecting garbage

Pruning

26 alts after pruning (23 fresh and 3 done)

	Pruned	Kept	Total
New	331	14	345
Fresh	9	9	18
Picked	3	2	5
Done	0	1	1
Total	343	26	369

Accuracy

100.0%

Counts

369 → 26

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	80.4%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
	57.3%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
	72.2%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) #s(approx (+ t a) t))))
▶	86.5%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))))
	81.2%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) #s(approx (* (+ (* (/ (log y) z) x) 1) z) z)) (+.f64 t a))))
	54.8%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))
	60.9%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))
	38.4%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))
	56.6%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
✓	42.1%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
	78.3%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a)))
	67.1%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t)))
▶	35.4%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
	72.0%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 x (log.f64 y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b))))
	79.2%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) a)) #s(literal 1 binary64)) a))))
	24.7%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
▶	63.3%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 (log.f64 y) x) t)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
	76.6%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (.f64 (fma.f64 t (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z) #s(literal 1 binary64)) z))) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
	78.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
	69.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
	19.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
	14.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
	23.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
▶	24.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
✓	3.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
✓	20.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 1 544 to 1 252 computations (18.9% saved)

series388.0ms (6.2%)

Memory

-1.0MiB live, 572.6MiB allocated; 55ms collecting garbage

Counts

39 → 413

Calls

Call 1

Inputs
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))))
y
i
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)))
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))
#s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(+.f64 (/.f64 z x) (log.f64 y))
(/.f64 z x)
z
x
(log.f64 y)
(+.f64 a t)
a
t
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b))
(*.f64 (log.f64 c) b)
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))
(+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)
#s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 (log.f64 y) x) t)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 (log.f64 y) x) t)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 (log.f64 y) x) t)) t)) a)
#s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 (log.f64 y) x) t)) t))
(.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 (log.f64 y) x) t)) t)
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (/.f64 (*.f64 (log.f64 y) x) t))
(/.f64 (*.f64 (log.f64 y) x) t)
(*.f64 (log.f64 y) x)
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(*.f64 y i)

Outputs
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 z))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 z))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (/ z x)))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (/ (+ z (* x (log y))) x)))
#s(approx (/ z x) #s(hole binary64 (/ z x)))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ z t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ (* t (+ 1 (/ z t))) (* x (log y)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (/ z t))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (/ z t) (/ (* x (log y)) t)))))
#s(approx (/ (* (log y) x) t) #s(hole binary64 (/ (* x (log y)) t)))
#s(approx (* (log y) x) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (log y)))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (log y) (/ z x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (+ (log y) (/ (* t (+ 1 (/ z t))) x)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (* x (log y)) t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* x (+ (/ 1 x) (+ (/ z (* t x)) (/ (log y) t))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* t (+ 1 (/ z t))) x)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) t)) (* -1 (/ (+ 1 (/ z t)) x)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx y #s(hole binary64 y))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (* y i) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 y)))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (* -1 (log (/ 1 y))) (/ z x)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (* -1 (log (/ 1 y))) (/ z x))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) t)) (/ z t))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) t)) (/ z t)))))
#s(approx (/ (* (log y) x) t) #s(hole binary64 (* -1 (/ (* x (log (/ 1 y))) t))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (/ z x))))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 y))) (/ z x)))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (/ z t) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t)))))
#s(approx (/ (* (log y) x) t) #s(hole binary64 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t)))
#s(approx (* (log y) x) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx z #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ (* x (log y)) t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* t (+ 1 (/ (* x (log y)) t))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (/ (* x (log y)) t))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (* z (+ (/ 1 x) (/ (log y) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* z (+ 1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ z t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* z (+ (/ 1 t) (+ (/ 1 z) (/ (* x (log y)) (* t z)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (log y) z)) (/ 1 x))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ 1 (/ (* x (log y)) t)) z)) (/ 1 t))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ a t) #s(hole binary64 a))
#s(approx (+ a t) #s(hole binary64 (+ a t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (+ z (* x (log y))) t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (+ t (+ z (* x (log y)))) t)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 t))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ a t) #s(hole binary64 t))
#s(approx (+ a t) #s(hole binary64 (* t (+ 1 (/ a t)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 1))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ a t) #s(hole binary64 (* -1 (* t (- (* -1 (/ a t)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ a t) #s(hole binary64 (* a (+ 1 (/ t a)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ a t) #s(hole binary64 (* -1 (* a (- (* -1 (/ t a)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (- b 1/2) #s(hole binary64 -1/2))
#s(approx (- b 1/2) #s(hole binary64 (- b 1/2)))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (* (log c) b) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (- b 1/2) #s(hole binary64 b))
#s(approx (- b 1/2) #s(hole binary64 (* b (- 1 (* 1/2 (/ 1 b))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (- b 1/2) #s(hole binary64 (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))))
#s(approx (log c) #s(hole binary64 (log c)))
#s(approx c #s(hole binary64 c))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (log c) #s(hole binary64 (* -1 (log (/ 1 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (* (log c) b) #s(hole binary64 (* -1 (* b (log (/ 1 c))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* (log (/ 1 c)) (- b 1/2)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (log c) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 c))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (* (log c) b) #s(hole binary64 (* b (+ (log -1) (* -1 (log (/ -1 c)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
#s(approx i #s(hole binary64 i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))

Calls

24 calls:

Time	Variable		Point	Expression
85.0ms	b	@	0	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) y i (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (log c) c (- b 1/2) b 1/2 (+ (+ (* (log y) x) z) (+ a t)) (+ (* (log y) x) z) (* (+ (/ z x) (log y)) x) (+ (/ z x) (log y)) (/ z x) z x (log y) (+ a t) a t (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (* (log c) b) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) (+ (+ (+ (* (log y) x) z) t) a) (+ (+ (* (log y) x) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (/ (+ (* (log y) x) z) t) 1) (/ (* (log y) x) t) (* (log y) x) (* (- b 1/2) (log c)) (* y i))
40.0ms	c	@	inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) y i (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (log c) c (- b 1/2) b 1/2 (+ (+ (* (log y) x) z) (+ a t)) (+ (* (log y) x) z) (* (+ (/ z x) (log y)) x) (+ (/ z x) (log y)) (/ z x) z x (log y) (+ a t) a t (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (* (log c) b) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) (+ (+ (+ (* (log y) x) z) t) a) (+ (+ (* (log y) x) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (/ (+ (* (log y) x) z) t) 1) (/ (* (log y) x) t) (* (log y) x) (* (- b 1/2) (log c)) (* y i))
37.0ms	c	@	0	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) y i (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (log c) c (- b 1/2) b 1/2 (+ (+ (* (log y) x) z) (+ a t)) (+ (* (log y) x) z) (* (+ (/ z x) (log y)) x) (+ (/ z x) (log y)) (/ z x) z x (log y) (+ a t) a t (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (* (log c) b) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) (+ (+ (+ (* (log y) x) z) t) a) (+ (+ (* (log y) x) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (/ (+ (* (log y) x) z) t) 1) (/ (* (log y) x) t) (* (log y) x) (* (- b 1/2) (log c)) (* y i))
31.0ms	i	@	inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) y i (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (log c) c (- b 1/2) b 1/2 (+ (+ (* (log y) x) z) (+ a t)) (+ (* (log y) x) z) (* (+ (/ z x) (log y)) x) (+ (/ z x) (log y)) (/ z x) z x (log y) (+ a t) a t (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (* (log c) b) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) (+ (+ (+ (* (log y) x) z) t) a) (+ (+ (* (log y) x) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (/ (+ (* (log y) x) z) t) 1) (/ (* (log y) x) t) (* (log y) x) (* (- b 1/2) (log c)) (* y i))
20.0ms	y	@	0	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) y i (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (log c) c (- b 1/2) b 1/2 (+ (+ (* (log y) x) z) (+ a t)) (+ (* (log y) x) z) (* (+ (/ z x) (log y)) x) (+ (/ z x) (log y)) (/ z x) z x (log y) (+ a t) a t (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (* (log c) b) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) (+ (+ (+ (* (log y) x) z) t) a) (+ (+ (* (log y) x) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+ (+ (+ (* x (log y)) z) t) a) (+ (+ (* x (log y)) z) t) (* (+ (/ (+ (* (log y) x) z) t) 1) t) (+ (/ (+ (* (log y) x) z) t) 1) (/ (* (log y) x) t) (* (log y) x) (* (- b 1/2) (log c)) (* y i))

rewrite258.0ms (4.1%)

Memory

-0.3MiB live, 326.8MiB allocated; 127ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	922	13054
0	956	12559
1	4902	12459
0	8190	11505

Stop Event

1×	iter-limit
1×	node-limit
1×	iter-limit

Counts

452 → 536

Calls

Call 1

Inputs
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))))
y
i
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t)))
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))
#s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(+.f64 (/.f64 z x) (log.f64 y))
(/.f64 z x)
z
x
(log.f64 y)
(+.f64 a t)
a
t
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b))
(*.f64 (log.f64 c) b)
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))
(+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)
#s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 (log.f64 y) x) t)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 (log.f64 y) x) t)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 (log.f64 y) x) t)) t)) a)
#s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 (log.f64 y) x) t)) t))
(.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 (log.f64 y) x) t)) t)
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (/.f64 (*.f64 (log.f64 y) x) t))
(/.f64 (*.f64 (log.f64 y) x) t)
(*.f64 (log.f64 y) x)
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(*.f64 y i)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 z))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 z))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (/ z x)))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (/ (+ z (* x (log y))) x)))
#s(approx (/ z x) #s(hole binary64 (/ z x)))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ z t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ (* t (+ 1 (/ z t))) (* x (log y)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (log y)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t z)))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (/ z t))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (/ z t) (/ (* x (log y)) t)))))
#s(approx (/ (* (log y) x) t) #s(hole binary64 (/ (* x (log y)) t)))
#s(approx (* (log y) x) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (log y) (/ z x)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (log y)))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (log y) (/ z x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* x (+ (log y) (/ (* t (+ 1 (/ z t))) x)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (/ z x))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (* x (log y)) t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* x (+ (/ 1 x) (+ (/ z (* t x)) (/ (log y) t))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* t (+ 1 (/ z t))) x)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t z) x)))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) t)) (* -1 (/ (+ 1 (/ z t)) x)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx y #s(hole binary64 y))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (* y i) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 y)))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (* -1 (log (/ 1 y))) (/ z x)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (* -1 (log (/ 1 y))) (/ z x))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) t)) (/ z t))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* -1 (* x (log (/ 1 y))))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) t)) (/ z t)))))
#s(approx (/ (* (log y) x) t) #s(hole binary64 (* -1 (/ (* x (log (/ 1 y))) t))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (/ z x))))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 y))) (/ z x)))))
#s(approx (log y) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 y))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (+ (/ z t) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t)))))
#s(approx (/ (* (log y) x) t) #s(hole binary64 (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) t)))
#s(approx (* (log y) x) #s(hole binary64 (* x (+ (log -1) (* -1 (log (/ -1 y)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx z #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* t (+ 1 (/ (* x (log y)) t)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* t (+ 1 (/ (* x (log y)) t))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ t (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ t (* x (log y)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (+ 1 (/ (* x (log y)) t))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (* z (+ (/ 1 x) (/ (log y) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* z (+ 1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 z))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 z))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 z))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (/ (* x (log y)) z))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ z t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* z (+ (/ 1 t) (+ (/ 1 z) (/ (* x (log y)) (* t z)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (* (+ (/ z x) (log y)) x) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#s(approx (+ (/ z x) (log y)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (log y) z)) (/ 1 x))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* t (+ 1 (/ (* x (log y)) t))) z)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (* x (log y))) z)) 1)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ 1 (/ (* x (log y)) t)) z)) (/ 1 t))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ a t) #s(hole binary64 a))
#s(approx (+ a t) #s(hole binary64 (+ a t)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ a (+ z (* x (log y))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (+ z (* x (log y)))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (+ z (* x (log y))) t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 (/ (+ t (+ z (* x (log y)))) t)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 t))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ a t) #s(hole binary64 t))
#s(approx (+ a t) #s(hole binary64 (* t (+ 1 (/ a t)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 t))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 t))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (/ (* x (log y)) t))))))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(hole binary64 1))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ a t) #s(hole binary64 (* -1 (* t (- (* -1 (/ a t)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* (log y) x) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))))
#s(approx (+ (+ (* x (log y)) z) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (* x (log y))) t)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (+ t (+ z (* x (log y))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ a t) #s(hole binary64 (* a (+ 1 (/ t a)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ a t) #s(hole binary64 (* -1 (* a (- (* -1 (/ t a)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* (log y) x) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (- b 1/2) #s(hole binary64 -1/2))
#s(approx (- b 1/2) #s(hole binary64 (- b 1/2)))
#s(approx b #s(hole binary64 b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (* (log c) b) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (- b 1/2) #s(hole binary64 b))
#s(approx (- b 1/2) #s(hole binary64 (* b (- 1 (* 1/2 (/ 1 b))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (log c))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (- b 1/2) #s(hole binary64 (* -1 (* b (- (* 1/2 (/ 1 b)) 1)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))))
#s(approx (log c) #s(hole binary64 (log c)))
#s(approx c #s(hole binary64 c))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (log c) #s(hole binary64 (* -1 (log (/ 1 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (* (log c) b) #s(hole binary64 (* -1 (* b (log (/ 1 c))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* -1 (* (log (/ 1 c)) (- b 1/2)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (log c) #s(hole binary64 (+ (log -1) (* -1 (log (/ -1 c))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (* (log c) b) #s(hole binary64 (* b (+ (log -1) (* -1 (log (/ -1 c)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a)) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (* (- b 1/2) (log c)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
#s(approx i #s(hole binary64 i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t)))) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a)))) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) #s(hole binary64 (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))))

Outputs
(/.f64 (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 t a) #s(approx (+ ( (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)))) #s(literal 2 binary64))) (-.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 t a) #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))))))
(/.f64 (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 t a) #s(approx (+ ( (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 t a) #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)))) #s(literal 2 binary64)) (.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 t a) #s(approx (+ ( (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))))))))
(fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 t a) #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 t a) #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)))))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) (+.f64 (+.f64 t a) #s(approx (+ ( (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))))
(+.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 t a) #s(approx (+ ( (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)))))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 t a) #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)))) (.f64 i y))
y
i
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (+.f64 (+.f64 t a) #s(approx (+ ( (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))) #s(literal 2 binary64))) (-.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 t a) #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (+.f64 (+.f64 t a) #s(approx (+ ( (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 (+.f64 t a) #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 t a) #s(approx (+ ( (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 t a) #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 (+.f64 t a) #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))) (+.f64 t a))
(+.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 t a) #s(approx (+ ( (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))))
(+.f64 (+.f64 (+.f64 t a) #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(log.f64 c)
c
(/.f64 (-.f64 (*.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64)))
(/.f64 (-.f64 (pow.f64 b #s(literal 3 binary64)) #s(literal 1/8 binary64)) (fma.f64 b b (+.f64 #s(literal 1/4 binary64) (*.f64 b #s(literal 1/2 binary64)))))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(/.f64 (-.f64 (pow.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(literal 2 binary64)) (pow.f64 (+.f64 t a) #s(literal 2 binary64))) (-.f64 #s(approx (+ ( (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 t a)))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(literal 3 binary64)) (pow.f64 (+.f64 t a) #s(literal 3 binary64))) (+.f64 (pow.f64 #s(approx (+ ( (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 t a)))))
(+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) a) t)
(+.f64 (+.f64 t a) #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)))
(+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 t a))
#s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(*.f64 x (+.f64 (/.f64 z x) (log.f64 y)))
(fma.f64 x (log.f64 y) (*.f64 (/.f64 z x) x))
(fma.f64 x (log.f64 y) (*.f64 x (/.f64 z x)))
(fma.f64 (log.f64 y) x (*.f64 (/.f64 z x) x))
(fma.f64 (log.f64 y) x (*.f64 x (/.f64 z x)))
(+.f64 (.f64 x (log.f64 y)) (.f64 (/.f64 z x) x))
(+.f64 (.f64 x (log.f64 y)) (.f64 x (/.f64 z x)))
(/.f64 (-.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (pow.f64 (/.f64 z x) #s(literal 2 binary64))) (-.f64 (log.f64 y) (/.f64 z x)))
(/.f64 (-.f64 (pow.f64 (/.f64 z x) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64))) (-.f64 (/.f64 z x) (log.f64 y)))
(/.f64 (+.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 (/.f64 z x) #s(literal 3 binary64))) (fma.f64 (log.f64 y) (log.f64 y) (-.f64 (pow.f64 (/.f64 z x) #s(literal 2 binary64)) (*.f64 (log.f64 y) (/.f64 z x)))))
(/.f64 (+.f64 (pow.f64 (/.f64 z x) #s(literal 3 binary64)) (pow.f64 (log.f64 y) #s(literal 3 binary64))) (+.f64 (pow.f64 (/.f64 z x) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (*.f64 (/.f64 z x) (log.f64 y)))))
(+.f64 (/.f64 z x) (log.f64 y))
(+.f64 (log.f64 y) (/.f64 z x))
(/.f64 (neg.f64 z) (neg.f64 x))
(/.f64 z x)
z
x
(log.f64 y)
(/.f64 (-.f64 (.f64 a a) (.f64 t t)) (-.f64 a t))
(/.f64 (-.f64 (.f64 t t) (.f64 a a)) (-.f64 t a))
(/.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))))
(/.f64 (+.f64 (pow.f64 t #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (fma.f64 t t (-.f64 (.f64 a a) (.f64 t a))))
(+.f64 t a)
(+.f64 a t)
a
t
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) z)
(/.f64 (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (pow.f64 #s(approx (+ ( (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (log.f64 c) b)) #s(literal 2 binary64))) (-.f64 (.f64 i y) #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (log.f64 c) b))))
(/.f64 (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 #s(approx (+ ( (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (log.f64 c) b)) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (log.f64 c) b)) #s(literal 2 binary64)) (.f64 (.f64 i y) #s(approx (+ ( (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (log.f64 c) b))))))
(fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (log.f64 c) b)))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (log.f64 c) b)) (.f64 i y))
(+.f64 (.f64 i y) #s(approx (+ ( (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (log.f64 c) b)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (log.f64 c) b))
(*.f64 (log.f64 c) b)
(*.f64 b (log.f64 c))
(log.f64 (pow.f64 c b))
(/.f64 (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (pow.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) a) #s(literal 2 binary64))) (-.f64 (.f64 i y) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) a)))
(/.f64 (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) a) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) a) #s(literal 2 binary64)) (.f64 (.f64 i y) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) a)))))
(fma.f64 i y (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) a))
(fma.f64 y i (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) a))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))
(+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) a) (*.f64 i y))
(+.f64 (.f64 i y) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) a))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) #s(literal 2 binary64))) (-.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) a)
(+.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))
(/.f64 (-.f64 (.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))) (.f64 a a)) (-.f64 #s(approx (+ (+ ( (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (fma.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) (-.f64 (.f64 a a) (.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a))))
(+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)
(+.f64 a #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)))
#s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a)) #s(literal 2 binary64)) (pow.f64 (.f64 i y) #s(literal 2 binary64))) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a)) (.f64 i y)))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a)) #s(literal 3 binary64)) (pow.f64 (.f64 i y) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a)) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ ( (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a)) (.f64 i y)))))
(fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a)))
(-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a)) (.f64 (neg.f64 y) i))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a)) (.f64 i y))
(+.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)))
(+.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ ( (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a)))
(/.f64 (-.f64 (pow.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (pow.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (+.f64 #s(approx (+ (+ ( (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a))
(-.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a) (.f64 (neg.f64 (-.f64 b #s(literal 1/2 binary64))) (log.f64 c)))
(+.f64 (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) a) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) (+.f64 a (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(+.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 #s(approx (+ (+ ( (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) #s(literal 2 binary64)) (.f64 a a)) (-.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (+.f64 (pow.f64 #s(approx (+ (+ ( (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 x (log.f64 y)) t)) t)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 #s(approx (+ (+ ( (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a))))
(+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a)
(+.f64 a #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)))
#s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t))
(.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)
(.f64 t #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t))
(*.f64 x (/.f64 (log.f64 y) t))
(*.f64 (log.f64 y) (/.f64 x t))
(/.f64 (neg.f64 (*.f64 x (log.f64 y))) (neg.f64 t))
(/.f64 (*.f64 x (log.f64 y)) t)
(*.f64 x (log.f64 y))
(*.f64 (log.f64 y) x)
(log.f64 (pow.f64 y x))
(*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(log.f64 (pow.f64 c (-.f64 b #s(literal 1/2 binary64))))
(*.f64 i y)
(*.f64 y i)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (+.f64 t z) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (fma.f64 x (log.f64 y) (+.f64 z (+.f64 t a))))
#s(approx (+ (* (log y) x) z) z)
#s(approx (+ (* (log y) x) z) (fma.f64 x (log.f64 y) z))
#s(approx (* (+ (/ z x) (log y)) x) z)
#s(approx (* (+ (/ z x) (log y)) x) (fma.f64 x (log.f64 y) z))
#s(approx (+ (/ z x) (log y)) (/.f64 z x))
#s(approx (+ (/ z x) (log y)) (/.f64 (fma.f64 x (log.f64 y) z) x))
#s(approx (/ z x) (/.f64 z x))
#s(approx x x)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (+.f64 t z) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (fma.f64 x (log.f64 y) (+.f64 z (+.f64 t a))))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 t z))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) t (*.f64 x (log.f64 y))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (+.f64 t z) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (fma.f64 x (log.f64 y) (+.f64 z (+.f64 t a))))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 t z))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (+.f64 (/.f64 z t) #s(literal 1 binary64)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) #s(literal 1 binary64)))
#s(approx (/ (* (log y) x) t) (/.f64 (*.f64 x (log.f64 y)) t))
#s(approx (* (log y) x) (*.f64 x (log.f64 y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 x (log.f64 y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (/.f64 (+.f64 t z) x) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) x))) x))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 x (log.f64 y)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 x (log.f64 y)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t z) a) x) (log.f64 y)) x))
#s(approx (+ (* (log y) x) z) (*.f64 x (log.f64 y)))
#s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
#s(approx (* (+ (/ z x) (log y)) x) (*.f64 x (log.f64 y)))
#s(approx (* (+ (/ z x) (log y)) x) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x))
#s(approx (+ (/ z x) (log y)) (log.f64 y))
#s(approx (+ (/ z x) (log y)) (+.f64 (/.f64 z x) (log.f64 y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 x (log.f64 y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (/.f64 (+.f64 t z) x) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) x))) x))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 x (log.f64 y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (/.f64 (+.f64 t z) x) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) x))) x))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 x (log.f64 y)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 x (log.f64 y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (/.f64 (+.f64 t z) x) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) x))) x))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 x (log.f64 y)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 x (log.f64 y)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t z) a) x) (log.f64 y)) x))
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 x (log.f64 y)))
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (+.f64 t z) x) (log.f64 y)) x))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 x (log.f64 y)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (fma.f64 t (/.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) x) (log.f64 y)) x))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 x (log.f64 y)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 x (log.f64 y)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t z) a) x) (log.f64 y)) x))
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 x (log.f64 y)))
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (+.f64 t z) x) (log.f64 y)) x))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (*.f64 (+.f64 (/.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) x) (/.f64 (log.f64 y) t)) x))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y))) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log y) x) z) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 z x) (neg.f64 (log.f64 y))) x)))
#s(approx (* (+ (/ z x) (log y)) x) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 z x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y))) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y))) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y))) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 t z) x) (neg.f64 (log.f64 y))) x)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (neg.f64 (.f64 (.f64 #s(literal -1 binary64) (fma.f64 t (/.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) x) (log.f64 y))) x)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) a) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (+.f64 t z) x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (/.f64 z t) #s(literal 1 binary64)) x) #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 y)) t)) x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx y y)
#s(approx (log y) (log.f64 y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) #s(literal 1 binary64)) t))
#s(approx (* y i) (*.f64 i y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 i y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (+.f64 t a) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z)))
#s(approx (+ (* (log y) x) z) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z))
#s(approx (* (+ (/ z x) (log y)) x) (*.f64 (fma.f64 (neg.f64 (log.f64 y)) #s(literal -1 binary64) (/.f64 z x)) x))
#s(approx (+ (/ z x) (log y)) (fma.f64 (neg.f64 (log.f64 y)) #s(literal -1 binary64) (/.f64 z x)))
#s(approx (log y) (neg.f64 (neg.f64 (log.f64 y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 i y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 i y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 i y))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (+.f64 t a) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z)))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) t)) #s(literal -1 binary64) (/.f64 z t)) #s(literal 1 binary64)) t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (+.f64 t a) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z)))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z) t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (+.f64 (fma.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) t)) #s(literal -1 binary64) (/.f64 z t)) #s(literal 1 binary64)))
#s(approx (/ (* (log y) x) t) (neg.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) t))))
#s(approx (* (log y) x) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (neg.f64 y) (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) a) y) #s(literal -1 binary64) (neg.f64 i))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (+.f64 t a) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z)))
#s(approx (+ (* (log y) x) z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z))
#s(approx (* (+ (/ z x) (log y)) x) (*.f64 (+.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (/.f64 z x)) (log.f64 #s(literal -1 binary64))) x))
#s(approx (+ (/ z x) (log y)) (+.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (/.f64 z x)) (log.f64 #s(literal -1 binary64))))
#s(approx (log y) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (neg.f64 y) (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) a) y) #s(literal -1 binary64) (neg.f64 i))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (neg.f64 y) (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) a) y) #s(literal -1 binary64) (neg.f64 i))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (neg.f64 y) (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) a) y) #s(literal -1 binary64) (neg.f64 i))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (+.f64 t a) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z)))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (+.f64 (/.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t) #s(literal 1 binary64)) t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (+.f64 t a) (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z)))
#s(approx (+ (+ (* (log y) x) z) t) (+.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (+.f64 (/.f64 (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x z) t) #s(literal 1 binary64)))
#s(approx (/ (* (log y) x) t) (*.f64 x (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) t)))
#s(approx (* (log y) x) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) x))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (fma.f64 x (log.f64 y) t) a))
#s(approx z z)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (fma.f64 x (log.f64 y) t) a))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) t z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (fma.f64 x (log.f64 y) t) a))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) z)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) z)) (/.f64 t z))) z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) z)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) t) z) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) z))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) z)
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z) #s(literal 1 binary64)) z))
#s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z))
#s(approx (* (+ (/ z x) (log y)) x) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z))
#s(approx (+ (/ z x) (log y)) (*.f64 (+.f64 (/.f64 (log.f64 y) z) (pow.f64 x #s(literal -1 binary64))) z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) z)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) z)) (/.f64 t z))) z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) z)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) z)) (/.f64 t z))) z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) z)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) t) z) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) z)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) z)) (/.f64 t z))) z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) z)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) t) z) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) z))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) z)
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z) #s(literal 1 binary64)) z))
#s(approx (+ (+ (* (log y) x) z) t) z)
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) t) z) #s(literal 1 binary64)) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z) #s(literal 1 binary64)) z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) z)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a z)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) t) z) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) z))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) z)
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z) #s(literal 1 binary64)) z))
#s(approx (+ (+ (* (log y) x) z) t) z)
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) t) z) #s(literal 1 binary64)) z))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (/.f64 z t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (*.f64 (+.f64 (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z) (pow.f64 t #s(literal -1 binary64))) z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* (log y) x) z) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (.f64 x (log.f64 y)) z)) #s(literal 1 binary64)) z)))
#s(approx (* (+ (/ z x) (log y)) x) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (.f64 x (log.f64 y)) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (/ z x) (log y)) (neg.f64 (*.f64 (-.f64 (/.f64 (neg.f64 (log.f64 y)) z) (pow.f64 x #s(literal -1 binary64))) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) t) z)) #s(literal 1 binary64)) z)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) t) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) t) a) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) t) z)) #s(literal 1 binary64)) z)))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z)) (pow.f64 t #s(literal -1 binary64))) z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (fma.f64 x (log.f64 y) z) a))
#s(approx (+ a t) a)
#s(approx (+ a t) (+.f64 t a))
#s(approx t t)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (fma.f64 x (log.f64 y) z) a))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 x (log.f64 y) z))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (+.f64 (fma.f64 x (log.f64 y) z) a))
#s(approx (+ (+ (* (log y) x) z) t) (fma.f64 x (log.f64 y) z))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (/.f64 (fma.f64 x (log.f64 y) z) t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) t)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y t) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) t)) (/.f64 z t))) t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) t)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) t)
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t) #s(literal 1 binary64)) t))
#s(approx (+ a t) t)
#s(approx (+ a t) (*.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) t)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y t) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) t)) (/.f64 z t))) t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) t)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y t) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) t)) (/.f64 z t))) t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) t)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) t)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y t) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) t)) (/.f64 z t))) t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) t)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) t)
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t) #s(literal 1 binary64)) t))
#s(approx (+ (+ (* (log y) x) z) t) t)
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) #s(literal 1 binary64)) t))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) t)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) t)
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t) #s(literal 1 binary64)) t))
#s(approx (+ (+ (* (log y) x) z) t) t)
#s(approx (+ (+ (* (log y) x) z) t) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) #s(literal 1 binary64)) t))
#s(approx (+ (/ (+ (* (log y) x) z) t) 1) #s(literal 1 binary64))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t)) #s(literal 1 binary64)) t)))
#s(approx (+ a t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 a t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) z) t)) #s(literal 1 binary64)) t)))
#s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) z) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 x (log.f64 y) z) a) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (* (log y) x) z) t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) z) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx a a)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (fma.f64 x (log.f64 y) (+.f64 t z)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) a)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) a)) (/.f64 z a))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) a)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) a)
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a) #s(literal 1 binary64)) a))
#s(approx (+ a t) (*.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) a)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) a)) (/.f64 z a))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) a)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) a)) (/.f64 z a))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) a)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) a)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) a)) (/.f64 z a))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) a)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) a)
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a) #s(literal 1 binary64)) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) a)
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) a)
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (*.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a) #s(literal 1 binary64)) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a)) #s(literal 1 binary64)) a)))
#s(approx (+ a t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 t a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (+ (* (log y) x) z) (+ a t)) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 x (log.f64 y) (+.f64 t z)) a)) #s(literal 1 binary64)) a)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (- b 1/2) #s(literal -1/2 binary64))
#s(approx (- b 1/2) (-.f64 b #s(literal 1/2 binary64)))
#s(approx b b)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (* (log c) b) (*.f64 (log.f64 c) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 x (log.f64 y) (*.f64 i y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 x (log.f64 y))) z) t) a))
#s(approx (* (- b 1/2) (log c)) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 (log.f64 c) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (.f64 i y)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) b) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (- b 1/2) b)
#s(approx (- b 1/2) (*.f64 (-.f64 #s(literal 1 binary64) (/.f64 #s(literal 1/2 binary64) b)) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 (log.f64 c) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (.f64 i y)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 (log.f64 c) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (.f64 i y)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) b) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (*.f64 (log.f64 c) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) (.f64 i y)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) b) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) b) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) b))
#s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 x (log.f64 y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (- b 1/2) (neg.f64 (*.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) b) #s(literal 1 binary64)) b)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 x (log.f64 y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 x (log.f64 y) (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 x (log.f64 y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 x (log.f64 y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (* (- b 1/2) (log c)) (neg.f64 (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal 1/2 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (log c) (log.f64 c))
#s(approx c c)
#s(approx (* (- b 1/2) (log c)) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 x (log.f64 y) (*.f64 i y)))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) a))
#s(approx (log c) (neg.f64 (neg.f64 (log.f64 c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 x (log.f64 y) (*.f64 i y)))) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 x (log.f64 y) (*.f64 i y)))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) a))
#s(approx (* (log c) b) (neg.f64 (*.f64 (neg.f64 (log.f64 c)) b)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 x (log.f64 y) (*.f64 i y)))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) a))
#s(approx (* (- b 1/2) (log c)) (*.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (log c) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z) t) a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (* (log c) b) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) b))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (+.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 x (log.f64 y)))) z) t) a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ a t))) (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))))
#s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (-.f64 b #s(literal 1/2 binary64))))
#s(approx i i)
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (/.f64 t i) (/.f64 z i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) i))) i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (/.f64 t i) (/.f64 z i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) i))) i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (/.f64 t i) (/.f64 z i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) i))) i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (/.f64 t i) (/.f64 z i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y))) i))) i))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ (+ (* (log y) x) z) t) a))) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 x (log.f64 y) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))

eval45.0ms (0.7%)

Memory: -7.1MiB live, 85.9MiB allocated; 12ms collecting garbage
Compiler: Compiled 13 064 to 1 683 computations (87.1% saved)

prune33.0ms (0.5%)

Memory

-2.1MiB live, 44.9MiB allocated; 2ms collecting garbage

Pruning

28 alts after pruning (23 fresh and 5 done)

	Pruned	Kept	Total
New	316	8	324
Fresh	3	15	18
Picked	3	2	5
Done	0	3	3
Total	322	28	350

Accuracy

100.0%

Counts

350 → 28

Alt Table

Click to see full alt table

Status	Accuracy	Program
	81.2%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (+.f64 t z)) a)))
	63.3%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a)))
	74.6%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (*.f64 x (log.f64 y))) a)))
	76.6%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z) #s(literal 1 binary64)) z))) a)))
	57.3%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)) a)))
	72.2%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) #s(approx (+ t a) t))))
	67.1%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(approx (+ a t) t))))
	54.8%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))
	60.9%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))
	38.4%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))
	56.6%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
	67.8%	(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
✓	42.1%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
	78.3%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a)))
	67.1%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t)))
✓	35.4%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
	72.0%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 x (log.f64 y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b))))
	79.2%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) a)) #s(literal 1 binary64)) a))))
	24.7%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
	63.2%	(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (.f64 (log.f64 y) (/.f64 x t))) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
	78.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
	69.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))
	19.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
	14.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
	23.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
✓	24.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
✓	3.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
✓	20.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 2 599 to 1 015 computations (60.9% saved)

regimes230.0ms (3.7%)

Memory

-4.1MiB live, 282.4MiB allocated; 25ms collecting garbage

Counts

55 → 1

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) t) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) z) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) #s(approx (* (+ (* (/ (log y) z) x) 1) z) z)) (+.f64 t a))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (+.f64 t z)) a)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) (*.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (log.f64 y) x)) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (*.f64 x (log.f64 y))) a)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(approx (+ a t) t))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) #s(approx (+ t a) t))))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (.f64 (log.f64 y) (/.f64 x t))) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 (log.f64 y) x) t)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) (+.f64 a t))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) (+.f64 t a))))
(+.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* (log y) x) z) (.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) #s(literal 1 binary64)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) i) #s(literal -1 binary64) (neg.f64 y))))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 x (log.f64 y)))) a)) #s(literal 1 binary64)) a))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (*.f64 (fma.f64 t (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z) #s(literal 1 binary64)) z))) a)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (.f64 i y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) (.f64 (fma.f64 t (/.f64 (fma.f64 x (/.f64 (log.f64 y) t) #s(literal 1 binary64)) z) #s(literal 1 binary64)) z))) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 x (log.f64 y))) z) t) a) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b))))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t)))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 x (log.f64 y) z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 a t)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (/.f64 t a)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) y)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) y) (/.f64 t y)) (/.f64 a y))) i) y))

Outputs
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))

Calls

12 calls:

29.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
27.0ms	(log.f64 c)
17.0ms	a
17.0ms	x
16.0ms	z

Results

Accuracy	Segments	Branch
99.8%	1	`(log.f64 c)`
99.8%	1	`(-.f64 b #s(literal 1/2 binary64))`
99.8%	1	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
99.8%	1	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`
99.8%	1	`x`
99.8%	1	`y`
99.8%	1	`z`
99.8%	1	`t`
99.8%	1	`a`
99.8%	1	`b`
99.8%	1	`c`
99.8%	1	`i`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes137.0ms (2.2%)

Memory

30.9MiB live, 174.3MiB allocated; 9ms collecting garbage

Counts

37 → 2

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) t) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) z) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) #s(approx (* (+ (* (/ (log y) z) x) 1) z) z)) (+.f64 t a))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (+.f64 t z)) a)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) (*.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (log.f64 y) x)) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (*.f64 x (log.f64 y))) a)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(approx (+ a t) t))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) #s(approx (+ t a) t))))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (.f64 (log.f64 y) (/.f64 x t))) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (.f64 (log.f64 y) x) t)) t)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))

Outputs

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (/.f64 (log.f64 y) z) x #s(literal 1 binary64)) z)) #s(approx (+ t a) t))))

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (*.f64 x (log.f64 y))) a)))

Calls

12 calls:

20.0ms	a
15.0ms	x
11.0ms	(-.f64 b #s(literal 1/2 binary64))
10.0ms	t
10.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))

Results

Accuracy	Segments	Branch
86.5%	3	`(log.f64 c)`
81.2%	1	`(-.f64 b #s(literal 1/2 binary64))`
86.1%	4	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
95.4%	2	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`
96.4%	3	`x`
92.1%	2	`y`
95.0%	2	`z`
87.1%	2	`t`
90.7%	3	`a`
81.2%	1	`b`
86.5%	3	`c`
93.7%	3	`i`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes34.0ms (0.5%)

Memory

-8.7MiB live, 83.5MiB allocated; 7ms collecting garbage

Counts

34 → 3

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) t) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) z) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) #s(approx (* (+ (* (/ (log y) z) x) 1) z) z)) (+.f64 t a))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (+.f64 t z)) a)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) (*.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (log.f64 y) x)) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (*.f64 x (log.f64 y))) a)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(approx (+ a t) t))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (.f64 #s(approx (+ (/ (+ ( (log y) x) z) t) 1) (/.f64 (*.f64 x (log.f64 y)) t)) t)) a)))

Outputs

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(approx (+ a t) t))))

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) #s(approx (* (+ (* (/ (log y) z) x) 1) z) z)) (+.f64 t a))))

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) (*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)) #s(approx (+ a t) t))))

Calls

3 calls:

12.0ms	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
11.0ms	x
9.0ms	z

Results

Accuracy	Segments	Branch
96.4%	3	`x`
94.1%	2	`z`
95.4%	3	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`

Compiler

Compiled 23 to 36 computations (-56.5% saved)

regimes22.0ms (0.3%)

Memory

8.2MiB live, 54.6MiB allocated; 3ms collecting garbage

Counts

32 → 2

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) t) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) z) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) #s(approx (* (+ (* (/ (log y) z) x) 1) z) z)) (+.f64 t a))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (+.f64 t z)) a)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) (*.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (log.f64 y) x)) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (*.f64 x (log.f64 y))) a)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))

Outputs

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) #s(approx (* (+ (* (/ (log y) z) x) 1) z) z)) (+.f64 t a))))

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (*.f64 x (log.f64 y))) a)))

Calls

2 calls:

11.0ms	x
9.0ms	z

Results

Accuracy	Segments	Branch
94.1%	2	`z`
94.2%	3	`x`

Compiler

Compiled 2 to 16 computations (-700% saved)

regimes100.0ms (1.6%)

Memory

-6.1MiB live, 97.3MiB allocated; 109ms collecting garbage

Counts

30 → 3

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) t) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) z) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) #s(approx (* (+ (* (/ (log y) z) x) 1) z) z)) (+.f64 t a))))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) (+.f64 t z)) a)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) (*.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (.f64 (log.f64 y) x)) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))

Outputs

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (* (log y) x) z) #s(approx (* (+ (* (/ (log y) z) x) 1) z) z)) (+.f64 t a))))

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))

Calls

5 calls:

60.0ms	z
13.0ms	i
8.0ms	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
8.0ms	x
8.0ms	y

Results

Accuracy	Segments	Branch
81.2%	1	`y`
81.2%	1	`i`
92.7%	3	`x`
81.2%	1	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`
81.2%	1	`z`

Compiler

Compiled 25 to 52 computations (-108% saved)

regimes10.0ms (0.2%)

Memory

-29.7MiB live, 17.7MiB allocated; 2ms collecting garbage

Counts

26 → 3

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) t) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) z) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 (+.f64 #s(approx (+ (+ (* x (log y)) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))

Outputs

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) (*.f64 x (log.f64 y)))))

Calls

1 calls:

7.0ms

Results

Accuracy	Segments	Branch
92.0%	3	`x`

Compiler

Compiled 1 to 8 computations (-700% saved)

regimes20.0ms (0.3%)

Memory

40.4MiB live, 40.4MiB allocated; 0ms collecting garbage

Counts

22 → 3

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) t) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))

Outputs

#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))

#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))

Calls

3 calls:

7.0ms	x
6.0ms	t
6.0ms	a

Results

Accuracy	Segments	Branch
80.4%	1	`t`
80.4%	1	`a`
88.7%	3	`x`

Compiler

Compiled 3 to 24 computations (-700% saved)

regimes125.0ms (2%)

Memory

0.9MiB live, 99.5MiB allocated; 6ms collecting garbage

Counts

21 → 2

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) t) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) t)) a)))

Outputs

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 #s(approx (+ (+ (* x (log y)) z) t) t) a)))

Calls

12 calls:

39.0ms	i
25.0ms	x
6.0ms	c
6.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
6.0ms	t

Results

Accuracy	Segments	Branch
74.8%	2	`a`
71.3%	2	`t`
76.3%	2	`z`
71.5%	3	`y`
67.8%	1	`i`
79.9%	2	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`
77.2%	3	`b`
77.2%	3	`(-.f64 b #s(literal 1/2 binary64))`
77.3%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
70.5%	2	`(log.f64 c)`
70.5%	2	`c`
76.7%	3	`x`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes34.0ms (0.5%)

Memory

-38.1MiB live, 8.8MiB allocated; 3ms collecting garbage

Counts

19 → 2

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) t) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))

Outputs

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) z)))

(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))

Calls

1 calls:

33.0ms

(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))

Results

Accuracy	Segments	Branch
79.6%	2	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`

Compiler

Compiled 21 to 20 computations (4.8% saved)

regimes42.0ms (0.7%)

Memory

-1.9MiB live, 45.1MiB allocated; 2ms collecting garbage

Counts

15 → 3

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (* (log y) x) z) (+ t a)) t)))

Outputs

#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))

(fma.f64 y i (fma.f64 (log.f64 c) #s(approx (- b 1/2) #s(literal -1/2 binary64)) (+.f64 #s(approx (+ (+ (* (log y) x) z) t) #s(approx (* (+ (/ (+ (* (log y) x) z) t) 1) t) z)) a)))

#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))

Calls

6 calls:

19.0ms	x
5.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
5.0ms	z
5.0ms	b
4.0ms	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))

Results

Accuracy	Segments	Branch
76.7%	3	`x`
75.9%	3	`b`
75.9%	3	`(-.f64 b #s(literal 1/2 binary64))`
76.1%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
74.0%	2	`z`
73.9%	2	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`

Compiler

Compiled 33 to 66 computations (-100% saved)

regimes59.0ms (0.9%)

Memory

38.9MiB live, 86.2MiB allocated; 2ms collecting garbage

Counts

12 → 3

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) t) (*.f64 y i))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) (*.f64 (log.f64 c) b)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))

Outputs

#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))

#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)

(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))

Calls

12 calls:

16.0ms	t
4.0ms	x
4.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
4.0ms	y
4.0ms	a

Results

Accuracy	Segments	Branch
46.5%	3	`i`
47.7%	3	`y`
42.1%	1	`(log.f64 c)`
42.1%	1	`c`
51.5%	3	`t`
61.5%	3	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`
55.0%	2	`z`
51.1%	3	`b`
51.1%	3	`(-.f64 b #s(literal 1/2 binary64))`
51.2%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
50.6%	3	`a`
52.6%	3	`x`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes9.0ms (0.1%)

Memory

-34.5MiB live, 14.4MiB allocated; 5ms collecting garbage

Counts

7 → 4

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ (+ (* (log y) x) z) (+ t a))) t))

Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))

Calls

2 calls:

5.0ms	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
3.0ms	z

Results

Accuracy	Segments	Branch
42.9%	3	`z`
56.1%	4	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`

Compiler

Compiled 22 to 28 computations (-27.3% saved)

regimes18.0ms (0.3%)

Memory

-3.7MiB live, 43.0MiB allocated; 4ms collecting garbage

Counts

3 → 2

Calls

Call 1

Inputs

#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)

#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)

Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Calls

9 calls:

5.0ms	i
2.0ms	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
2.0ms	a
2.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
2.0ms	x

Results

Accuracy	Segments	Branch
26.6%	2	`i`
28.5%	2	`y`
37.0%	2	`a`
24.9%	1	`(-.f64 b #s(literal 1/2 binary64))`
24.9%	1	`b`
27.8%	2	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
34.9%	2	`t`
24.9%	1	`x`
44.1%	2	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`

Compiler

Compiled 36 to 90 computations (-150% saved)

regimes17.0ms (0.3%)

Memory

17.1MiB live, 64.4MiB allocated; 1ms collecting garbage

Accuracy

Total -11.8b remaining (-23.2%)

Threshold costs -11.8b (-23.2%)

Counts

2 → 1

Calls

Call 1

Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) t)

Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Calls

12 calls:

2.0ms	i
2.0ms	(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
1.0ms	b
1.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
1.0ms	(log.f64 c)

Results

Accuracy	Segments	Branch
20.6%	1	`(-.f64 b #s(literal 1/2 binary64))`
20.6%	1	`x`
20.6%	1	`b`
20.6%	1	`i`
20.6%	1	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
20.6%	1	`y`
20.6%	1	`t`
20.6%	1	`a`
20.6%	1	`z`
20.6%	1	`(log.f64 c)`
20.6%	1	`c`
20.6%	1	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

bsearch1.0ms (0%)

Memory

2.7MiB live, 2.7MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-44.33050858786167	130.33411148724625

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch50.0ms (0.8%)

Memory

-18.8MiB live, 76.3MiB allocated; 9ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
19.0ms	2.1190297059508314e+109	6.6797612950330285e+115
24.0ms	-3.1390073813944576e+180	-4.502401040424806e+179

Samples

32.0ms

240×

valid

Compiler

Compiled 954 to 796 computations (16.6% saved)

Precisions

Click to see histograms. Total time spent on operations: 12.0ms

ival-log: 5.0ms (43.3% of total)

ival-mult!: 3.0ms (26% of total)

ival-add!: 2.0ms (17.3% of total)

ival-sub!: 1.0ms (8.7% of total)

adjust: 0.0ms (0% of total)

bsearch23.0ms (0.4%)

Memory

2.7MiB live, 49.9MiB allocated; 3ms collecting garbage

Algorithm

1×	binary-search

Stop Event

1×	narrow-enough

Steps

Time	Left	Right
19.0ms	-7.185521605892188e+154	-2.9709036399273813e+149

Samples

13.0ms

144×

valid

Compiler

Compiled 528 to 463 computations (12.3% saved)

Precisions

Click to see histograms. Total time spent on operations: 7.0ms

ival-log: 3.0ms (42.4% of total)

ival-mult!: 2.0ms (28.2% of total)

ival-add!: 1.0ms (14.1% of total)

ival-sub!: 0.0ms (0% of total)

adjust: 0.0ms (0% of total)

bsearch43.0ms (0.7%)

Memory

15.3MiB live, 62.3MiB allocated; 3ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
20.0ms	4.2513212888707636e+172	4.14716385172466e+175
19.0ms	-3.117450972973821e+186	-3.1390073813944576e+180

Samples

27.0ms

272×

valid

Compiler

Compiled 976 to 847 computations (13.2% saved)

Precisions

Click to see histograms. Total time spent on operations: 17.0ms

ival-log: 10.0ms (58.7% of total)

ival-mult!: 4.0ms (23.5% of total)

ival-add!: 3.0ms (17.6% of total)

ival-sub!: 1.0ms (5.9% of total)

adjust: 0.0ms (0% of total)

bsearch3.0ms (0%)

Memory

7.0MiB live, 7.0MiB allocated; 0ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
1.0ms	4.2513212888707636e+172	4.14716385172466e+175
1.0ms	-3.117450972973821e+186	-3.1390073813944576e+180

Compiler

Compiled 1 010 to 830 computations (17.8% saved)

bsearch43.0ms (0.7%)

Memory

-11.1MiB live, 87.8MiB allocated; 12ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
22.0ms	1.2851453928766296e+211	1.9066832045168876e+216
16.0ms	-3.117450972973821e+186	-3.1390073813944576e+180

Samples

26.0ms

256×

valid

Compiler

Compiled 1 104 to 913 computations (17.3% saved)

Precisions

Click to see histograms. Total time spent on operations: 12.0ms

ival-log: 6.0ms (48.9% of total)

ival-mult!: 3.0ms (24.5% of total)

ival-add!: 2.0ms (16.3% of total)

ival-sub!: 1.0ms (8.2% of total)

adjust: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory

2.2MiB live, 2.2MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-44.33050858786167	130.33411148724625

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch0.0ms (0%)

Memory

1.2MiB live, 1.2MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-44.33050858786167	130.33411148724625

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch13.0ms (0.2%)

Memory

25.5MiB live, 25.5MiB allocated; 0ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
11.0ms	1.2851453928766296e+211	1.9066832045168876e+216
1.0ms	-3.117450972973821e+186	-3.1390073813944576e+180

Samples

7.0ms

80×

valid

Compiler

Compiled 1 140 to 949 computations (16.8% saved)

Precisions

Click to see histograms. Total time spent on operations: 4.0ms

ival-log: 2.0ms (52.7% of total)

ival-add!: 1.0ms (26.3% of total)

ival-mult!: 1.0ms (26.3% of total)

ival-sub!: 0.0ms (0% of total)

adjust: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory

1.3MiB live, 1.3MiB allocated; 0ms collecting garbage

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	-44.33050858786167	130.33411148724625
0.0ms	-inf	-1.6498676219563946e+308

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

1.3MiB live, 1.3MiB allocated; 0ms collecting garbage

Algorithm

3×	left-value

Steps

Time	Left	Right
0.0ms	4.498877073984911e+302	3.420714901441403e+303
0.0ms	-44.33050858786167	130.33411148724625
0.0ms	-inf	-1.6498676219563946e+308

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch0.0ms (0%)

Memory

0.7MiB live, 0.7MiB allocated; 0ms collecting garbage

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-44.33050858786167	130.33411148724625

Compiler

Compiled 24 to 31 computations (-29.2% saved)

derivations482.0ms (7.7%)

Memory

-32.9MiB live, 588.6MiB allocated; 32ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 1 139 to 145 computations (87.3% saved)

preprocess150.0ms (2.4%)

Memory: 30.4MiB live, 412.2MiB allocated; 19ms collecting garbage
Compiler: Compiled 4 598 to 1 366 computations (70.3% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze19.0ms (0.3%)

sample1.7s (27%)

explain230.0ms (3.7%)

preprocess45.0ms (0.7%)

series319.0ms (5.1%)

rewrite205.0ms (3.3%)

eval25.0ms (0.4%)

prune34.0ms (0.5%)

series353.0ms (5.6%)

rewrite213.0ms (3.4%)

eval44.0ms (0.7%)

prune20.0ms (0.3%)

series334.0ms (5.3%)

rewrite269.0ms (4.3%)

eval50.0ms (0.8%)

prune24.0ms (0.4%)

series388.0ms (6.2%)

rewrite258.0ms (4.1%)

eval45.0ms (0.7%)

prune33.0ms (0.5%)

regimes230.0ms (3.7%)

regimes137.0ms (2.2%)

regimes34.0ms (0.5%)

regimes22.0ms (0.3%)

regimes100.0ms (1.6%)

regimes10.0ms (0.2%)

regimes20.0ms (0.3%)

regimes125.0ms (2%)

regimes34.0ms (0.5%)

regimes42.0ms (0.7%)

regimes59.0ms (0.9%)

regimes9.0ms (0.1%)

regimes18.0ms (0.3%)

regimes17.0ms (0.3%)

bsearch1.0ms (0%)

bsearch50.0ms (0.8%)

bsearch23.0ms (0.4%)

bsearch43.0ms (0.7%)

bsearch3.0ms (0%)

bsearch43.0ms (0.7%)

bsearch1.0ms (0%)

bsearch0.0ms (0%)

bsearch13.0ms (0.2%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch0.0ms (0%)

derivations482.0ms (7.7%)

preprocess150.0ms (2.4%)

end0.0ms (0%)

Profiling