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

analyze13.0ms (0.2%)

Memory

23.3MiB live, 23.3MiB allocated; 0ms 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.6s (24.7%)

Memory

23.9MiB live, 2 056.6MiB allocated; 360ms collecting garbage

Samples

1.1s	8 255×	0	valid
0.0ms	1×	1	valid

Precisions

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

ival-log: 264.0ms (38.7% of total)

ival-mult!: 213.0ms (31.2% of total)

ival-add!: 175.0ms (25.7% of total)

ival-sub!: 27.0ms (4% of total)

adjust: 2.0ms (0.3% of total)

Bogosity

explain254.0ms (3.8%)

Memory

-20.2MiB live, 233.8MiB allocated; 21ms 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

53.0ms

512×

valid

Compiler

Compiled 207 to 64 computations (69.1% saved)

Precisions

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

ival-log: 11.0ms (43.2% of total)

ival-mult!: 7.0ms (27.5% of total)

ival-add!: 5.0ms (19.6% of total)

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

adjust: 0.0ms (0% of total)

preprocess146.0ms (2.2%)

Memory

12.2MiB live, 150.7MiB allocated; 11ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	245	969
1	791	965
2	3526	962
3	5742	962
0	20	21
0	31	21
1	53	21
2	148	21
3	598	21
4	1903	21
5	3203	21
6	3289	21
7	3295	21
8	3295	21
9	3947	21
10	3977	21
11	3977	21
0	3977	18

Stop Event

1×	iter limit
1×	saturated
1×	iter limit
1×	node limit

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))

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))

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

Symmetry

(sort z t a)

Compiler

Compiled 21 to 20 computations (4.8% saved)

eval0.0ms (0%)

Memory: 0.2MiB live, 0.2MiB allocated; 0ms collecting garbage
Compiler: Compiled 0 to 8 computations (-∞% saved)

prune1.0ms (0%)

Memory

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

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	99.9%	(+.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)

series271.0ms (4.1%)

Memory

38.3MiB live, 553.3MiB allocated; 56ms 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
53.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)
49.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)
30.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	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)) x (log y) y z t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i)
20.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)) x (log y) y z t a (* (- b 1/2) (log c)) (- b 1/2) b 1/2 (log c) c (* y i) i)

rewrite385.0ms (5.8%)

Memory

-47.8MiB live, 295.8MiB allocated; 238ms 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))))

eval23.0ms (0.3%)

Memory: 33.5MiB live, 33.5MiB allocated; 0ms collecting garbage
Compiler: Compiled 6 891 to 996 computations (85.5% saved)

prune23.0ms (0.3%)

Memory

-21.3MiB live, 25.8MiB allocated; 2ms collecting garbage

Pruning

19 alts after pruning (19 fresh and 0 done)

	Pruned	Kept	Total
New	186	19	205
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	187	19	206

Accuracy

100.0%

Counts

206 → 19

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	99.9%	(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))))
	86.9%	(+.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))
	66.0%	(+.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))
	61.0%	(+.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))
▶	65.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))
	62.5%	(+.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))
	36.6%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x)) (.f64 y i))
	70.1%	(+.f64 #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))) (.f64 y i))
▶	44.6%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z) (*.f64 y i))
	50.2%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
▶	76.3%	#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))
	73.5%	#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))
	13.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
	15.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
	25.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
	78.9%	#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)))
	21.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
▶	27.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 1 162 to 970 computations (16.5% saved)

series177.0ms (2.7%)

Memory

13.2MiB live, 203.5MiB allocated; 17ms collecting garbage

Counts

29 → 246

Calls

Call 1

Inputs
(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))))
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)))
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))
(+.f64 a t)
a
t
(fma.f64 (log.f64 y) x z)
(log.f64 y)
x
z
#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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z)
(*.f64 y i)
(+.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 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) a)
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (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 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(+.f64 (+.f64 a t) (+.f64 (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 z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))

Outputs
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (* (log c) (- b 1/2)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (+ (log y) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ z (* (log c) (- b 1/2))) x)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ (* x (log y)) (* (log c) (- b 1/2)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #s(hole binary64 z))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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) (* (log c) (- b 1/2))) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* z (+ 1 (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) z)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #s(hole binary64 t))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #s(hole binary64 a))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* x (log y)) b)))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* b (log c))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* x (log y)))) b)))))))
#s(approx (* (log c) (- b 1/2)) #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 (* (log c) (- b 1/2)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* -1 (* (log (/ 1 c)) (- b 1/2)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
#s(approx (* (log c) (- b 1/2)) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #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)))))))

Calls

24 calls:

Time	Variable		Point	Expression
22.0ms	b	@	-inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) y i (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) (log c) c (- b 1/2) b 1/2 (+ (+ a t) (+ (* (log y) x) z)) (+ a t) a t (+ (* (log y) x) z) (log y) x z (+ (+ (+ (+ (+ (* 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))) (* 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)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (* (log c) (- b 1/2)))
16.0ms	c	@	-inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) y i (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) (log c) c (- b 1/2) b 1/2 (+ (+ a t) (+ (* (log y) x) z)) (+ a t) a t (+ (* (log y) x) z) (log y) x z (+ (+ (+ (+ (+ (* 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))) (* 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)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (* (log c) (- b 1/2)))
15.0ms	z	@	0	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) y i (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) (log c) c (- b 1/2) b 1/2 (+ (+ a t) (+ (* (log y) x) z)) (+ a t) a t (+ (* (log y) x) z) (log y) x z (+ (+ (+ (+ (+ (* 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))) (* 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)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (* (log c) (- b 1/2)))
15.0ms	y	@	inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) y i (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) (log c) c (- b 1/2) b 1/2 (+ (+ a t) (+ (* (log y) x) z)) (+ a t) a t (+ (* (log y) x) z) (log y) x z (+ (+ (+ (+ (+ (* 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))) (* 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)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (* (log c) (- b 1/2)))
14.0ms	y	@	-inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) y i (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) (log c) c (- b 1/2) b 1/2 (+ (+ a t) (+ (* (log y) x) z)) (+ a t) a t (+ (* (log y) x) z) (log y) x z (+ (+ (+ (+ (+ (* 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))) (* 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)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (* (log c) (- b 1/2)))

rewrite287.0ms (4.3%)

Memory

10.9MiB live, 289.4MiB allocated; 83ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	661	7500
0	690	6945
1	3941	6903
0	11139	6767

Stop Event

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

Counts

275 → 453

Calls

Call 1

Inputs
(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))))
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)))
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z))
(+.f64 a t)
a
t
(fma.f64 (log.f64 y) x z)
(log.f64 y)
x
z
#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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z)
(*.f64 y i)
(+.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 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) a)
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (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 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(+.f64 (+.f64 a t) (+.f64 (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 z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #s(hole binary64 (+ a (+ t z))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (* (log c) (- b 1/2)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (+ (log y) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ z (* (log c) (- b 1/2))) x)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (* i y)))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ (* x (log y)) (* (log c) (- b 1/2)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 z))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #s(hole binary64 z))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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) (* (log c) (- b 1/2))) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* z (+ 1 (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) z)) 1)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 t))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 t))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #s(hole binary64 t))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 a))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 a))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #s(hole binary64 a))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ (+ a t) (+ (* (log y) x) z)) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z))) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* x (log y)) b)))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* b (log c))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* x (log y)))) b)))))))
#s(approx (* (log c) (- b 1/2)) #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 (* (log c) (- b 1/2)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* -1 (* (log (/ 1 c)) (- b 1/2)))))
#s(approx (+ (* y i) (+ (* (log c) (- b 1/2)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z))) #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 (+ (+ (+ (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
#s(approx (* (log c) (- b 1/2)) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #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)) (+ (+ a t) (+ (* (log y) x) z)))) #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)))))))

Outputs
(/.f64 (fma.f64 (-.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 a (fma.f64 (log.f64 y) x (+.f64 z t))) (.f64 (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (-.f64 (.f64 a a) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64))))) (.f64 (-.f64 (.f64 i y) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (-.f64 a (fma.f64 (log.f64 y) x (+.f64 z t)))))
(/.f64 (fma.f64 (-.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 t a) (fma.f64 (log.f64 y) x z)) (.f64 (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (-.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64))))) (.f64 (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (-.f64 (+.f64 t a) (fma.f64 (log.f64 y) x z))))
(/.f64 (fma.f64 (-.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 (log.f64 y) x (+.f64 z t)) a) (.f64 (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (.f64 a a)))) (.f64 (-.f64 (.f64 i y) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (-.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)))
(/.f64 (fma.f64 (-.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))) (fma.f64 a a (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 z t))))) (.f64 (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 3 binary64))))) (.f64 (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (fma.f64 a a (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 z t)))))))
(/.f64 (fma.f64 (-.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 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (.f64 (+.f64 t a) (fma.f64 (log.f64 y) x z)))) (.f64 (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 t a) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64))))) (.f64 (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (.f64 (+.f64 t a) (fma.f64 (log.f64 y) x z))))))
(/.f64 (fma.f64 (-.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 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a))) (.f64 (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))))) (.f64 (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)))))
(/.f64 (fma.f64 (+.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 a (fma.f64 (log.f64 y) x (+.f64 z t))) (.f64 (+.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 a) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64))))) (.f64 (+.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 a (fma.f64 (log.f64 y) x (+.f64 z t)))))
(/.f64 (fma.f64 (+.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 t a) (fma.f64 (log.f64 y) x z)) (.f64 (+.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 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64))))) (.f64 (+.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 t a) (fma.f64 (log.f64 y) x z))))
(/.f64 (fma.f64 (+.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 (log.f64 y) x (+.f64 z t)) a) (.f64 (+.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 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (.f64 a a)))) (.f64 (+.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 (log.f64 y) x (+.f64 z t)) a)))
(/.f64 (fma.f64 (+.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))) (fma.f64 a a (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 z t))))) (.f64 (+.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 (pow.f64 a #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 3 binary64))))) (.f64 (+.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)))))) (fma.f64 a a (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 z t)))))))
(/.f64 (fma.f64 (+.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 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (.f64 (+.f64 t a) (fma.f64 (log.f64 y) x z)))) (.f64 (+.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 (pow.f64 (+.f64 t a) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64))))) (.f64 (+.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 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (.f64 (+.f64 t a) (fma.f64 (log.f64 y) x z))))))
(/.f64 (fma.f64 (+.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 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a))) (.f64 (+.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 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))))) (.f64 (+.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 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #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 z t))) (-.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 z t))) (-.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 z t)) #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 z t))) (+.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 z t))) (+.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 (+.f64 t a) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64))) (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (-.f64 (+.f64 t a) (fma.f64 (log.f64 y) x 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 (+.f64 t a) (fma.f64 (log.f64 y) x z)) (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 y) x 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 (+.f64 t a) (fma.f64 (log.f64 y) x 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 (+.f64 t a) (fma.f64 (log.f64 y) x 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 z t)) #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 z t)) 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 z t)) 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 z t)) #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 z t)) 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 z t)) 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 z t)) #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 z t)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 z t))))) (-.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 z t)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 z t))))) (-.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 z t)) #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 z t)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 z t))))) (+.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 z t)) #s(literal 2 binary64)) (.f64 a (fma.f64 (log.f64 y) x (+.f64 z t))))) (+.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 (+.f64 t a) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64))) (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (+.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (.f64 (+.f64 t a) (fma.f64 (log.f64 y) x 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 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (.f64 (+.f64 t a) (fma.f64 (log.f64 y) x z)))) (-.f64 (.f64 i y) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 (+.f64 t a) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x 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 (+.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (.f64 (+.f64 t a) (fma.f64 (log.f64 y) x 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 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (.f64 (+.f64 t a) (fma.f64 (log.f64 y) x 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 z t)) #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 z t)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) 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 z t)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) 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 z t)) #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 z t)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) 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 z t)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) 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 (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 (fma.f64 (log.f64 y) x t) a) z)) #s(literal 2 binary64))) (-.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) z)) (.f64 i y)))
(/.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 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) z)) #s(literal 2 binary64)) (.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z))))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) z)) (.f64 i y)))))
(fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))
(-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)) (*.f64 (neg.f64 y) i))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z))
(+.f64 (*.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)) (*.f64 i y))
(+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)))
y
i
(/.f64 (fma.f64 (-.f64 (.f64 z z) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64))) (-.f64 a t) (.f64 (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (-.f64 (.f64 a a) (.f64 t t)))) (.f64 (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (-.f64 a t)))
(/.f64 (fma.f64 (-.f64 (.f64 z z) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t)))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (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 a t) (.f64 (-.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (-.f64 (.f64 a a) (.f64 t t)))) (.f64 (-.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (-.f64 a t)))
(/.f64 (fma.f64 (-.f64 (pow.f64 (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))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (-.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (-.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (fma.f64 a a (-.f64 (.f64 t t) (*.f64 a t)))))
(/.f64 (fma.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 3 binary64))) (-.f64 a t) (.f64 (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))) (-.f64 (.f64 a a) (.f64 t t)))) (.f64 (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))) (-.f64 a t)))
(/.f64 (fma.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 3 binary64))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))) (fma.f64 a a (-.f64 (.f64 t t) (*.f64 a t)))))
(/.f64 (fma.f64 (+.f64 (pow.f64 (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 a t) (.f64 (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (-.f64 (.f64 a a) (.f64 t t)))) (.f64 (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (-.f64 a t)))
(/.f64 (fma.f64 (+.f64 (pow.f64 (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))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (fma.f64 a a (-.f64 (.f64 t t) (*.f64 a t)))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (.f64 (-.f64 a t) (-.f64 (.f64 z z) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64))))) (.f64 (-.f64 a t) (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (-.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (-.f64 a t) (-.f64 (pow.f64 (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 a t) (-.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))) (.f64 (-.f64 a t) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 3 binary64))))) (.f64 (-.f64 a t) (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (.f64 (-.f64 a t) (+.f64 (pow.f64 (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 (-.f64 a t) (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 (.f64 z z) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64))))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (-.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 (pow.f64 (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 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 3 binary64))))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #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 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (+.f64 (pow.f64 (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 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (-.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) #s(literal 2 binary64))) (-.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) #s(literal 2 binary64))) (-.f64 a (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t)))
(/.f64 (-.f64 (pow.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) #s(literal 2 binary64))) (-.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))
(/.f64 (+.f64 (pow.f64 (+.f64 t a) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))))
(/.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) #s(literal 3 binary64))) (fma.f64 a a (-.f64 (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) #s(literal 2 binary64)) (*.f64 a (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t)))))
(/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) z) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z))
(-.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) (*.f64 (neg.f64 (-.f64 b #s(literal 1/2 binary64))) (log.f64 c)))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 t a)) (fma.f64 (log.f64 y) x z))
(+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) (+.f64 t a))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) (+.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(+.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)
(+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))
(+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z))
(+.f64 a (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t))
(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 (fma.f64 (-.f64 (.f64 z z) (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64))) (-.f64 a t) (.f64 (-.f64 z (.f64 (log.f64 y) x)) (-.f64 (.f64 a a) (.f64 t t)))) (.f64 (-.f64 z (.f64 (log.f64 y) x)) (-.f64 a t)))
(/.f64 (fma.f64 (-.f64 (.f64 z z) (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (-.f64 z (.f64 (log.f64 y) x)) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (-.f64 z (.f64 (log.f64 y) x)) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t)))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z z)) (-.f64 a t) (.f64 (-.f64 (.f64 (log.f64 y) x) z) (-.f64 (.f64 a a) (.f64 t t)))) (.f64 (-.f64 (.f64 (log.f64 y) x) z) (-.f64 a t)))
(/.f64 (fma.f64 (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z z)) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (-.f64 (.f64 (log.f64 y) x) z) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (-.f64 (.f64 (log.f64 y) x) z) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t)))))
(/.f64 (fma.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64))) (-.f64 a t) (.f64 (fma.f64 z z (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z (.f64 (log.f64 y) x)))) (-.f64 (.f64 a a) (.f64 t t)))) (.f64 (fma.f64 z z (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z (*.f64 (log.f64 y) x)))) (-.f64 a t)))
(/.f64 (fma.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (fma.f64 z z (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z (.f64 (log.f64 y) x)))) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (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 a a (-.f64 (.f64 t t) (*.f64 a t)))))
(/.f64 (fma.f64 (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (-.f64 a t) (.f64 (+.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 a a) (.f64 t t)))) (.f64 (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (.f64 z z) (.f64 (*.f64 (log.f64 y) x) z))) (-.f64 a t)))
(/.f64 (fma.f64 (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (.f64 z z) (.f64 (.f64 (log.f64 y) x) z))) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (.f64 z z) (.f64 (.f64 (log.f64 y) x) z))) (fma.f64 a a (-.f64 (.f64 t t) (*.f64 a t)))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (-.f64 z (.f64 (log.f64 y) x)) (.f64 (-.f64 a t) (-.f64 (.f64 z z) (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64))))) (.f64 (-.f64 a t) (-.f64 z (.f64 (log.f64 y) x))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (-.f64 (.f64 (log.f64 y) x) z) (.f64 (-.f64 a t) (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z z)))) (.f64 (-.f64 a t) (-.f64 (.f64 (log.f64 y) x) z)))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (fma.f64 z z (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z (.f64 (log.f64 y) x)))) (.f64 (-.f64 a t) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64))))) (.f64 (-.f64 a t) (fma.f64 z z (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z (*.f64 (log.f64 y) x))))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (+.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 a t) (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (.f64 (-.f64 a t) (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (.f64 z z) (.f64 (*.f64 (log.f64 y) x) z)))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (-.f64 z (.f64 (log.f64 y) x)) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 (.f64 z z) (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64))))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 z (.f64 (log.f64 y) x))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (-.f64 (.f64 (log.f64 y) x) z) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z z)))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 (.f64 (log.f64 y) x) z)))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #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)))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64))))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (fma.f64 z z (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (.f64 z (*.f64 (log.f64 y) x))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #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 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (+.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 (*.f64 a a) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64))) (-.f64 a (fma.f64 (log.f64 y) x (+.f64 z t))))
(/.f64 (-.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64))) (-.f64 (+.f64 t a) (fma.f64 (log.f64 y) x z)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a))
(/.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 3 binary64))) (fma.f64 a a (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (*.f64 a (fma.f64 (log.f64 y) x (+.f64 z t))))))
(/.f64 (+.f64 (pow.f64 (+.f64 t a) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (fma.f64 (log.f64 y) x z)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 3 binary64)) (pow.f64 a #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) #s(literal 2 binary64)) (-.f64 (.f64 a a) (.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a))))
(+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+.f64 (fma.f64 (log.f64 y) x z) (+.f64 t a))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x z))
(+.f64 a (fma.f64 (log.f64 y) x (+.f64 z t)))
(/.f64 (-.f64 (.f64 a a) (.f64 t t)) (-.f64 a t))
(/.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 t a)
(+.f64 a t)
a
t
(/.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 2 binary64)) (.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)))))
(/.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))))
(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))
(log.f64 y)
x
z
#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))) z) #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))) z) (*.f64 i y)))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z) #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))) z) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z) (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z) (*.f64 i y)))))
(fma.f64 i y #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z))
(-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z) (*.f64 (neg.f64 y) i))
(+.f64 (.f64 i y) #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z) (*.f64 i y))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z)
(*.f64 i y)
(*.f64 y i)
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) 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)) #s(approx (+ (+ (+ ( x (log y)) z) t) a) a)) (*.f64 i y)))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) 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)) #s(approx (+ (+ (+ ( x (log y)) z) t) a) 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)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a)) (*.f64 i y)))))
(fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a)))
(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a)))
(-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a)) (*.f64 (neg.f64 y) i))
(+.f64 (.f64 i y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (+ ( x (log y)) z) t) a) a)))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a)) (*.f64 i y))
(+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #s(literal 2 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 #s(approx (+ (+ (+ ( x (log y)) z) t) a) a) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 #s(approx (+ (+ (+ ( x (log y)) z) t) a) a) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a))
(-.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) 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))) #s(approx (+ (+ (+ ( x (log y)) z) t) a) a))
(+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) 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))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))
(/.f64 (fma.f64 (-.f64 (.f64 z z) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64))) (-.f64 a t) (.f64 (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (-.f64 (.f64 a a) (.f64 t t)))) (.f64 (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (-.f64 a t)))
(/.f64 (fma.f64 (-.f64 (.f64 z z) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t)))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (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 a t) (.f64 (-.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (-.f64 (.f64 a a) (.f64 t t)))) (.f64 (-.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (-.f64 a t)))
(/.f64 (fma.f64 (-.f64 (pow.f64 (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))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (-.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (-.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (fma.f64 a a (-.f64 (.f64 t t) (*.f64 a t)))))
(/.f64 (fma.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 3 binary64))) (-.f64 a t) (.f64 (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))) (-.f64 (.f64 a a) (.f64 t t)))) (.f64 (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))) (-.f64 a t)))
(/.f64 (fma.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 3 binary64))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))) (fma.f64 a a (-.f64 (.f64 t t) (*.f64 a t)))))
(/.f64 (fma.f64 (+.f64 (pow.f64 (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 a t) (.f64 (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (-.f64 (.f64 a a) (.f64 t t)))) (.f64 (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (-.f64 a t)))
(/.f64 (fma.f64 (+.f64 (pow.f64 (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))) (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (.f64 (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))))) (.f64 (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (fma.f64 a a (-.f64 (.f64 t t) (*.f64 a t)))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (.f64 (-.f64 a t) (-.f64 (.f64 z z) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64))))) (.f64 (-.f64 a t) (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (-.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (-.f64 a t) (-.f64 (pow.f64 (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 a t) (-.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))) (.f64 (-.f64 a t) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 3 binary64))))) (.f64 (-.f64 a t) (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))))))
(/.f64 (fma.f64 (-.f64 (.f64 a a) (.f64 t t)) (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (.f64 (-.f64 a t) (+.f64 (pow.f64 (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 (-.f64 a t) (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 (.f64 z z) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64))))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (-.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 (pow.f64 (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 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (-.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 t #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 3 binary64))))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 a #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 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (.f64 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (+.f64 (pow.f64 (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 (fma.f64 a a (-.f64 (.f64 t t) (.f64 a t))) (+.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (-.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) #s(literal 2 binary64))) (-.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) #s(literal 2 binary64))) (-.f64 a (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t)))
(/.f64 (-.f64 (pow.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (pow.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) #s(literal 2 binary64))) (-.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))
(/.f64 (+.f64 (pow.f64 (+.f64 t a) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) #s(literal 2 binary64)) (*.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))))
(/.f64 (+.f64 (pow.f64 a #s(literal 3 binary64)) (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) #s(literal 3 binary64))) (fma.f64 a a (-.f64 (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) #s(literal 2 binary64)) (*.f64 a (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t)))))
(/.f64 (+.f64 (pow.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) 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 (fma.f64 (log.f64 y) x t) a) z) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z))
(-.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) (*.f64 (neg.f64 (-.f64 b #s(literal 1/2 binary64))) (log.f64 c)))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 t a)) (fma.f64 (log.f64 y) x z))
(+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) (+.f64 t a))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) (+.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(+.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)
(+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))
(+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z))
(+.f64 a (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t))
(/.f64 (-.f64 (.f64 z z) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64))) (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))
(/.f64 (-.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))))
(/.f64 (+.f64 (pow.f64 (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 (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 (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)) (fma.f64 (log.f64 y) x z))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 (log.f64 y) x z))
(fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
(fma.f64 x (log.f64 y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
(-.f64 (fma.f64 (log.f64 y) x z) (*.f64 (neg.f64 (log.f64 c)) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) z)
(+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 (log.f64 y) x z))
(+.f64 (*.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
(+.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.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))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 z t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y))) a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 z t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))) a))
#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))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 z t) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z))
#s(approx (+ (* (log y) x) z) z)
#s(approx (+ (* (log y) x) z) (fma.f64 (log.f64 y) x z))
#s(approx x x)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 z t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y))) a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 z t) (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))) a))
#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))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 z t) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) 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))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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 z t) 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 z t) a) 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) 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 z t) 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 z t) a) x) (log.f64 y)) 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 (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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 (+.f64 z t) (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 (+ (+ (+ (+ (* 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 z t) 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 (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 z t) (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 (+ (+ (+ (+ (* 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 z t) a) 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 (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))
#s(approx y y)
#s(approx (log y) (log.f64 y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)))
#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 z t) (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 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 (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 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 z t) (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 t a) (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))) (+.f64 (+.f64 (+.f64 z t) (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) (* (log c) (- b 1/2))) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x))) 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 (+.f64 z t) (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 (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 z t) (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 (+ (+ (+ (* x (log y)) z) t) a) (+.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 (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 (neg.f64 y) (fma.f64 (/.f64 (+.f64 (+.f64 (+.f64 z t) (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 (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 z t) (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 (+ (+ (+ (* x (log y)) z) t) a) (+.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 (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 z t) (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) (* (log c) (- b 1/2))) (+.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) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 t a) (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 z z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 t a) (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) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 t a) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (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))) (* 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 (+ (* (log y) x) 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)) 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) 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 (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (.f64 (+.f64 (/.f64 (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))) (* y i)) (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 (log.f64 y) x))) t) a) 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 t a) (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 (+ (* (log y) x) 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)) (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 (log.f64 y) x))) t) a) 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 t a) (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) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 t a) (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 (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (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))) (* 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 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (fma.f64 (log.f64 y) x z) a))
#s(approx (+ a t) a)
#s(approx (+ a t) (+.f64 t a))
#s(approx t t)
#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 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (fma.f64 (log.f64 y) x z) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) 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)) (.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 (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 (/.f64 a t) #s(literal 1 binary64)) (+.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 (+ a t) t)
#s(approx (+ a t) (*.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) 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 (/.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 (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 (/.f64 a t) #s(literal 1 binary64)) (+.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) a) (* (- b 1/2) (log c))) t)
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.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) (* (- 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 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) a) 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 (+ a t) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 a 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 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) a) 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) a) (* (- b 1/2) (log c))) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) a) t)) #s(literal 1 binary64)) t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 z 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 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (fma.f64 (log.f64 y) x (+.f64 z t)))
#s(approx a a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 z 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 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (fma.f64 (log.f64 y) x (+.f64 z t)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t))
#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 (/.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 (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 (/.f64 t a) #s(literal 1 binary64)) (+.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 z t)) a) #s(literal 1 binary64)) a))
#s(approx (+ a t) (*.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) 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 (/.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 (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 (/.f64 t a) #s(literal 1 binary64)) (+.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 z t)) a) #s(literal 1 binary64)) 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 (/.f64 t a) #s(literal 1 binary64)) (+.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) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 z t) (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 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) 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 z t)) 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 (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 z t) (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 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) 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 z t)) 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 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) 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 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (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))) (+.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 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x)) 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 (+ (+ (+ (+ (+ (* 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 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (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))) (+.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 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x)) 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 (+ (+ (+ (+ (* 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 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x)) z) t) a))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+.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 (+ (+ (+ (+ (+ (* 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) 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)) (*.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 (+ (+ (+ (+ (* 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 (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (/.f64 (fma.f64 (log.f64 y) x z) b)) (log.f64 c)) 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 (+ (+ (+ (+ (+ (* 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) (neg.f64 (*.f64 (-.f64 (/.f64 #s(literal 1/2 binary64) b) #s(literal 1 binary64)) 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 (+ (+ (+ (+ (* 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 (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 (log.f64 y) x)) z) 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 (* (- b 1/2) (log c)) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 z t) (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 z t) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) a))
#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 (+.f64 z t) (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 z t) (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 (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 (+.f64 z t) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) a))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+.f64 (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) z))
#s(approx (* (- b 1/2) (log c)) (*.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.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 (log.f64 y) x))) z) t) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 t a) (+.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 (log c) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #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 (+.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) t) a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 t a) (+.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 (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.f64 (+.f64 t a) (+.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 (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+.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 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 (+.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 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)) i) #s(literal -1 binary64) (neg.f64 y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (neg.f64 i) (fma.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)) i) #s(literal -1 binary64) (neg.f64 y))))

eval51.0ms (0.8%)

Memory: -3.6MiB live, 91.2MiB allocated; 12ms collecting garbage
Compiler: Compiled 16 429 to 1 539 computations (90.6% saved)

prune21.0ms (0.3%)

Memory

2.4MiB live, 49.6MiB allocated; 2ms collecting garbage

Pruning

21 alts after pruning (19 fresh and 2 done)

	Pruned	Kept	Total
New	385	13	398
Fresh	8	6	14
Picked	3	2	5
Done	0	0	0
Total	396	21	417

Accuracy

100.0%

Counts

417 → 21

Alt Table

Click to see full alt table

Status	Accuracy	Program
	62.5%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t)))
	36.6%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
▶	78.4%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)) #s(literal 1 binary64)) a))))
▶	44.6%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z))
	50.2%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))
	50.0%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (/.f64 (-.f64 (.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64))) (log.f64 c))) (*.f64 y i))
	65.6%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #s(approx (* (- b 1/2) (log c)) (.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))) (.f64 y i))
✓	44.6%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z) (*.f64 y i))
▶	74.1%	#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) #s(approx (- b 1/2) b)))))
	63.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
	58.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (log.f64 y)) x))))
▶	39.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
	41.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
	47.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
	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))
	73.5%	#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))
	13.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
	15.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
	25.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
▶	21.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
✓	27.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 1 428 to 1 100 computations (23% saved)

series278.0ms (4.2%)

Memory

2.3MiB live, 521.9MiB allocated; 59ms collecting garbage

Counts

37 → 364

Calls

Call 1

Inputs
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)) #s(literal 1 binary64)) a))))
y
i
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)) #s(literal 1 binary64)) a)))
(neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)) #s(literal 1 binary64)) a))
(*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)) #s(literal 1 binary64)) a)
(-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)) #s(literal 1 binary64))
(neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a))
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)
(+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t)
(fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
(log.f64 y)
x
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
z
t
a
#s(literal 1 binary64)
#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))) 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))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
(+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x)))
(+.f64 a t)
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))
(*.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) #s(approx (- b 1/2) b)))))
(+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b))))
(+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))
(fma.f64 (log.f64 y) x z)
(*.f64 (log.f64 c) #s(approx (- b 1/2) b))
#s(approx (- b 1/2) b)

Outputs
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (- (* x (log y)) (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (+ (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))) (* -1 (* x (log y))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (- (* -1 (/ (* x (log y)) a)) (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (- (* -1 (/ (* x (log y)) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (* (log c) (- b 1/2)))) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (* (log c) (- b 1/2))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (* (log c) (- b 1/2)))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (* (log c) (- b 1/2)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
#s(approx (* (log y) x) #s(hole binary64 (* 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 (+ (* 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* x (log y))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* x (- (/ (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x) (* -1 (log y))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* x (log y)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* x (+ (* -1 (log y)) (* -1 (/ (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (/ (* x (log y)) a))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* x (- (* -1 (/ (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x)) (/ (log y) a)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (/ (* x (log y)) a))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* x (- (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)) (/ (log y) a)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (* x (log y)) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* x (+ (log y) (+ (/ z x) (/ (* (log c) (- b 1/2)) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (+ (log y) (+ (/ z x) (/ (* (log c) (- b 1/2)) 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 (+ (* 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)) (log y))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* x (+ (log y) (/ (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (* x (- (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))) (* -1 (/ (log y) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (* x (- (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))) (* -1 (/ (log y) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (+ z (* (log c) (- b 1/2)))) x)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ z (* (log c) (- b 1/2))) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ z (* (log c) (- b 1/2))) x)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#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 y #s(hole binary64 y))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)))
#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 (* 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
#s(approx (* (log y) x) #s(hole binary64 (* 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 (+ (* 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (- z (* -1 (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (+ (* -1 z) (* -1 (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (- (* -1 (/ z a)) (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (- (* -1 (/ z a)) (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ (* x (log y)) (* (log c) (- b 1/2)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* (log c) (- b 1/2)))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ (* 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 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 z))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* z (+ 1 (/ (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 z)))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* z (- (* -1 (/ (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (/ z a))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* z (- (* -1 (/ (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (/ z a))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ z a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 z))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* z (+ 1 (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* z (+ 1 (/ (* (log c) (- b 1/2)) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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) (* (log c) (- b 1/2))) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* z (+ 1 (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* z (+ 1 (/ (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (* z (+ (/ 1 a) (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) z)) 1)))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* (log c) (- b 1/2)) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) z)) 1)))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (- t (* -1 (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (+ (* -1 t) (* -1 (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (- (* -1 (/ t a)) (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (- (* -1 (/ t a)) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ a t) #s(hole binary64 a))
#s(approx (+ a t) #s(hole binary64 (+ a 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 t))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* t (+ 1 (/ (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 t)))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* t (- (* -1 (/ (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (/ t a))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* t (- (* -1 (/ (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (/ t a))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ t a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 t))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ a t) #s(hole binary64 t))
#s(approx (+ a t) #s(hole binary64 (* t (+ 1 (/ a t)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* t (+ 1 (/ (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (* t (+ (/ 1 a) (+ (/ 1 t) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ a t) #s(hole binary64 (* -1 (* t (- (* -1 (/ a t)) 1)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (- a (* -1 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (+ (* -1 a) (* -1 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (/ (- (* -1 a) (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ 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))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 a))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 a)))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 -1))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ a t) #s(hole binary64 (* a (+ 1 (/ t a)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #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) (* (- 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ a t) #s(hole binary64 (* -1 (* a (- (* -1 (/ t a)) 1)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (- (* b (log c)) (* -1 (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (+ (* -1 (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))) (* -1 (* b (log c))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (- (* -1 (/ (* b (log c)) a)) (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (- (* -1 (/ (* b (log c)) a)) (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (* x (log y))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* -1/2 (log c)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (+ (* -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 (+ 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* b (log c))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* b (- (/ (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b) (* -1 (log c))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* b (log c)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* b (+ (* -1 (log c)) (* -1 (/ (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (/ (* b (log c)) a))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* b (- (* -1 (/ (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b)) (/ (log c) a)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (/ (* b (log c)) a))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* b (- (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)) (/ (log c) a)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (* b (log c)) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* x (log y)) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ z 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* x (log y)) b)))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* b (log c))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* -1 (* b (- (* -1 (/ (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)) (log c))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* b (+ (log c) (/ (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (* b (- (+ (* -1/2 (/ (log c) (* a b))) (+ (/ 1 b) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (* x (log y)) (* a b)))))) (* -1 (/ (log c) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (* b (- (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (* x (log y)) (* a b))))) (* -1 (/ (log c) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))) b)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* x (log y)))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (* -1/2 (log c))) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* x (log y)))) b)))))))
#s(approx (* (log c) (- b 1/2)) #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 (* (log c) (- b 1/2)) #s(hole binary64 (* (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 (+ (* -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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* -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 (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* -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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* (+ (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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
#s(approx i #s(hole binary64 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 (+ (+ (+ (+ (+ (* 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 (* -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)))))))

Calls

24 calls:

Time	Variable		Point	Expression
23.0ms	a	@	-inf	((+ (* 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))) (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (log y) x (+ (* (log c) (- b 1/2)) z) (log c) c (- b 1/2) b 1/2 z t a 1 (+ (+ (+ (+ (+ (* 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)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (* (log y) x) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+ (* (log y) x) z) (* (log c) (- b 1/2)) (- b 1/2))
22.0ms	c	@	inf	((+ (* 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))) (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (log y) x (+ (* (log c) (- b 1/2)) z) (log c) c (- b 1/2) b 1/2 z t a 1 (+ (+ (+ (+ (+ (* 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)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (* (log y) x) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+ (* (log y) x) z) (* (log c) (- b 1/2)) (- b 1/2))
22.0ms	a	@	inf	((+ (* 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))) (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (log y) x (+ (* (log c) (- b 1/2)) z) (log c) c (- b 1/2) b 1/2 z t a 1 (+ (+ (+ (+ (+ (* 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)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (* (log y) x) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+ (* (log y) x) z) (* (log c) (- b 1/2)) (- b 1/2))
19.0ms	c	@	-inf	((+ (* 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))) (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (log y) x (+ (* (log c) (- b 1/2)) z) (log c) c (- b 1/2) b 1/2 z t a 1 (+ (+ (+ (+ (+ (* 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)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (* (log y) x) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+ (* (log y) x) z) (* (log c) (- b 1/2)) (- b 1/2))
18.0ms	y	@	inf	((+ (* 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))) (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (log y) x (+ (* (log c) (- b 1/2)) z) (log c) c (- b 1/2) b 1/2 z t a 1 (+ (+ (+ (+ (+ (* 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)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (* (log y) x) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+ (* (log y) x) z) (* (log c) (- b 1/2)) (- b 1/2))

rewrite237.0ms (3.6%)

Memory

-4.8MiB live, 232.3MiB allocated; 28ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1051	13204
0	1085	12100
1	6174	12029
0	8190	11742

Stop Event

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

Counts

401 → 500

Calls

Call 1

Inputs
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)) #s(literal 1 binary64)) a))))
y
i
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)) #s(literal 1 binary64)) a)))
(neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)) #s(literal 1 binary64)) a))
(*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)) #s(literal 1 binary64)) a)
(-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)) #s(literal 1 binary64))
(neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a))
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a)
(+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t)
(fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
(log.f64 y)
x
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
z
t
a
#s(literal 1 binary64)
#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))) 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))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
(+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x)))
(+.f64 a t)
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))
(*.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) #s(approx (- b 1/2) b)))))
(+.f64 (+.f64 a t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b))))
(+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))
(fma.f64 (log.f64 y) x z)
(*.f64 (log.f64 c) #s(approx (- b 1/2) b))
#s(approx (- b 1/2) b)
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (- (* x (log y)) (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (+ (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))) (* -1 (* x (log y))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (- (* -1 (/ (* x (log y)) a)) (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (- (* -1 (/ (* x (log y)) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (* (log c) (- b 1/2)))) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (* (log c) (- b 1/2))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (* (log c) (- b 1/2)))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (* (log c) (- b 1/2)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
#s(approx (* (log y) x) #s(hole binary64 (* 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 (+ (* 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* x (log y))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* x (- (/ (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x) (* -1 (log y))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* x (log y)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* x (+ (* -1 (log y)) (* -1 (/ (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (/ (* x (log y)) a))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* x (- (* -1 (/ (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x)) (/ (log y) a)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (/ (* x (log y)) a))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* x (- (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)) (/ (log y) a)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (* x (log y)) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* x (+ (log y) (+ (/ z x) (/ (* (log c) (- b 1/2)) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (+ (log y) (+ (/ z x) (/ (* (log c) (- b 1/2)) 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 (+ (* 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* -1 (* x (- (* -1 (/ (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)) (log y))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* x (+ (log y) (/ (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (* x (- (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))) (* -1 (/ (log y) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (* x (- (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))) (* -1 (/ (log y) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (+ z (* (log c) (- b 1/2)))) x)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ z (* (log c) (- b 1/2))) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ z (* (log c) (- b 1/2))) x)))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))))
#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 y #s(hole binary64 y))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)))
#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 (* 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (+ z (* -1 (* x (log (/ 1 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
#s(approx (* (log y) x) #s(hole binary64 (* 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 (+ (* 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (- z (* -1 (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (+ (* -1 z) (* -1 (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (- (* -1 (/ z a)) (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (- (* -1 (/ z a)) (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ (* x (log y)) (* (log c) (- b 1/2)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* (log c) (- b 1/2)))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ (* 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 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 z))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* z (+ 1 (/ (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 z)))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* z (- (* -1 (/ (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (/ z a))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* z (- (* -1 (/ (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (/ z a))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ z a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* z (+ 1 (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 z))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* z (+ 1 (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* z (+ 1 (/ (* (log c) (- b 1/2)) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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) (* (log c) (- b 1/2))) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* z (+ 1 (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* z (+ 1 (/ (* x (log y)) z)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* z (+ 1 (/ (* a (+ 1 (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (* z (+ (/ 1 a) (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) z)) 1)))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* (log c) (- b 1/2)) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) z)) 1)))))
#s(approx (+ (* (log y) x) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (- t (* -1 (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (+ (* -1 t) (* -1 (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (- (* -1 (/ t a)) (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (- (* -1 (/ t a)) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ a t) #s(hole binary64 a))
#s(approx (+ a t) #s(hole binary64 (+ a 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 t))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* t (+ 1 (/ (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 t)))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* t (- (* -1 (/ (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (/ t a))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* t (- (* -1 (/ (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (/ t a))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ t a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 t))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* t (+ 1 (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))))
#s(approx (+ a t) #s(hole binary64 t))
#s(approx (+ a t) #s(hole binary64 (* t (+ 1 (/ a t)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* t (+ 1 (/ (* a (+ 1 (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (* t (+ (/ 1 a) (+ (/ 1 t) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))))
#s(approx (+ a t) #s(hole binary64 (* -1 (* t (- (* -1 (/ a t)) 1)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (- a (* -1 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (+ (* -1 a) (* -1 (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (/ (- (* -1 a) (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a))))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ 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))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 a))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 a)))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 -1))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))))
#s(approx (+ a t) #s(hole binary64 (* a (+ 1 (/ t a)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #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) (* (- 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))))
#s(approx (+ a t) #s(hole binary64 (* -1 (* a (- (* -1 (/ t a)) 1)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (- (* b (log c)) (* -1 (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (+ (* -1 (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))) (* -1 (* b (log c))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (- (* -1 (/ (* b (log c)) a)) (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (- (* -1 (/ (* b (log c)) a)) (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (* x (log y))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* -1/2 (log c)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (+ (* -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 (+ 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* b (log c))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* b (- (/ (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b) (* -1 (log c))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* b (log c)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* b (+ (* -1 (log c)) (* -1 (/ (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (/ (* b (log c)) a))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* b (- (* -1 (/ (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b)) (/ (log c) a)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (/ (* b (log c)) a))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* b (- (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)) (/ (log c) a)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (* b (log c)) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* x (log y)) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ z 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* x (log y)) b)))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* b (log c))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) 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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* -1 (* b (- (* -1 (/ (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)) (log c))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* b (+ (log c) (/ (* a (+ 1 (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (* b (- (+ (* -1/2 (/ (log c) (* a b))) (+ (/ 1 b) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (* x (log y)) (* a b)))))) (* -1 (/ (log c) a)))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (* b (- (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (* x (log y)) (* a b))))) (* -1 (/ (log c) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))) b)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* x (log y)))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (* -1/2 (log c))) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* x (log y)))) b)))))))
#s(approx (* (log c) (- b 1/2)) #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 (* (log c) (- b 1/2)) #s(hole binary64 (* (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 (+ (* -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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* -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 (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* -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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) #s(hole binary64 (* -1 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(hole binary64 (* -1 (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) #s(hole binary64 (* -1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) #s(hole binary64 (/ (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))) a)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) #s(hole binary64 (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) #s(hole binary64 (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* (+ (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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
#s(approx (* (log c) (- b 1/2)) #s(hole binary64 (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
#s(approx i #s(hole binary64 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 (+ (+ (+ (+ (+ (* 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 (* -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)))))))

Outputs
(/.f64 (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (pow.f64 #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))) #s(literal 2 binary64))) (-.f64 (.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64))))))
(/.f64 (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))) #s(literal 2 binary64)) (.f64 (.f64 i y) #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64))))))))
(fma.f64 i y #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))))
(+.f64 (.f64 i y) #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))) (.f64 i y))
y
i
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64))))
(*.f64 (neg.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64))) a)
(*.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))
(.f64 #s(literal -1 binary64) (.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)) a))
(.f64 (.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)) a) #s(literal -1 binary64))
(*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)) (neg.f64 a))
(neg.f64 (*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)) a))
(*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)) a)
(*.f64 a (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))
(/.f64 (-.f64 (pow.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 2 binary64)) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))
(/.f64 (-.f64 (pow.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 3 binary64)) #s(literal 1 binary64)) (+.f64 (pow.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 2 binary64)) (+.f64 #s(literal 1 binary64) (*.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))))
(-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64))
(*.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a))
(*.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a) #s(literal -1 binary64))
(/.f64 (neg.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t))) a)
(/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a))
(neg.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a))
(fma.f64 #s(literal -1 binary64) (/.f64 t a) (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a)))
(fma.f64 (/.f64 t a) #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a)))
(+.f64 (/.f64 (neg.f64 t) a) (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a)))
(/.f64 (-.f64 (pow.f64 (/.f64 t a) #s(literal 2 binary64)) (pow.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 2 binary64))) (-.f64 (/.f64 t a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a)))
(/.f64 (+.f64 (pow.f64 (/.f64 t a) #s(literal 3 binary64)) (pow.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 3 binary64))) (+.f64 (pow.f64 (/.f64 t a) #s(literal 2 binary64)) (-.f64 (pow.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 2 binary64)) (*.f64 (/.f64 t a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a)))))
(/.f64 (neg.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t))) (neg.f64 a))
(/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a)
(+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) a))
(+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) (/.f64 t a))
(+.f64 (/.f64 t a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 t t)) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) t))
(/.f64 (-.f64 (*.f64 t t) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64))) (-.f64 t (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (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 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (-.f64 (.f64 t t) (.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) t))))
(/.f64 (+.f64 (pow.f64 t #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))) (fma.f64 t t (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 t (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z))))))
(fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t))
(fma.f64 x (log.f64 y) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t))
(+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) t)
(+.f64 t (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)))
(+.f64 (*.f64 (log.f64 y) x) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t))
(/.f64 (-.f64 (pow.f64 (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 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 2 binary64))) (-.f64 (.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))
(/.f64 (-.f64 (.f64 z z) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64))) (-.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))
(/.f64 (+.f64 (pow.f64 (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 (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 (fma.f64 (log.f64 y) x z) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 2 binary64)) (.f64 (.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))))
(/.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 (log.f64 y) x z))
(fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
(fma.f64 x (log.f64 y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
(-.f64 (fma.f64 (log.f64 y) x z) (*.f64 (neg.f64 (log.f64 c)) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) (*.f64 (log.f64 y) x))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) z)
(+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 (log.f64 y) x z))
(+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))
(+.f64 (*.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
(log.f64 y)
x
(/.f64 (-.f64 (.f64 z z) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 z (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (.f64 z z)) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z))
(/.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (log.f64 (pow.f64 (pow.f64 c (-.f64 b #s(literal 1/2 binary64))) z)))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (.f64 z z) (.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)
(-.f64 z (*.f64 (neg.f64 (log.f64 c)) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z)
(+.f64 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)
z
t
a
#s(literal 1 binary64)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) z)
(/.f64 (-.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (pow.f64 #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) z) #s(literal 2 binary64))) (-.f64 (.f64 i y) #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) z)))
(/.f64 (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) z) #s(literal 3 binary64))) (+.f64 (pow.f64 (.f64 i y) #s(literal 2 binary64)) (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) z) #s(literal 2 binary64)) (.f64 (.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z)))))
(fma.f64 i y #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z))
(+.f64 (.f64 i y) #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z) (*.f64 i y))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (log.f64 y) x))))
(/.f64 (-.f64 (pow.f64 (+.f64 a t) #s(literal 2 binary64)) (pow.f64 #s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (.f64 (log.f64 y) x)) #s(literal 2 binary64))) (-.f64 (+.f64 a t) #s(approx (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (log.f64 y) x))))
(/.f64 (+.f64 (pow.f64 (+.f64 a t) #s(literal 3 binary64)) (pow.f64 #s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (.f64 (log.f64 y) x)) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 a t) #s(literal 2 binary64)) (-.f64 (pow.f64 #s(approx (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) (.f64 (log.f64 y) x)) #s(literal 2 binary64)) (.f64 (+.f64 a t) #s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (log.f64 y) x))))))
(+.f64 (+.f64 a t) #s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (log.f64 y) x)))
(+.f64 #s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (log.f64 y) x)) (+.f64 a t))
(+.f64 a (+.f64 t #s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (log.f64 y) x))))
(/.f64 (-.f64 (.f64 a a) (.f64 t t)) (-.f64 a t))
(/.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)
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(*.f64 x (log.f64 y))
(log.f64 (pow.f64 y x))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.f64 (+.f64 a t) (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) (fma.f64 (log.f64 y) x z))))
(/.f64 (-.f64 (pow.f64 (+.f64 a t) #s(literal 2 binary64)) (pow.f64 (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64))) (-.f64 (+.f64 a t) (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) (fma.f64 (log.f64 y) x z))))
(/.f64 (+.f64 (pow.f64 (+.f64 a t) #s(literal 3 binary64)) (pow.f64 (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))) (+.f64 (pow.f64 (+.f64 a t) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 (+.f64 a t) (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) (fma.f64 (log.f64 y) x z))))))
(+.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 y) x z)) (*.f64 #s(approx (- b 1/2) b) (log.f64 c)))
(+.f64 (+.f64 a t) (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) (fma.f64 (log.f64 y) x z)))
(+.f64 (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) (fma.f64 (log.f64 y) x z)) (+.f64 a t))
(+.f64 a (+.f64 t (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) (fma.f64 (log.f64 y) x z))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (pow.f64 (.f64 #s(approx (- b 1/2) b) (log.f64 c)) #s(literal 2 binary64))) (-.f64 (fma.f64 (log.f64 y) x z) (.f64 #s(approx (- b 1/2) b) (log.f64 c))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64)) (pow.f64 (.f64 #s(approx (- b 1/2) b) (log.f64 c)) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (pow.f64 (.f64 #s(approx (- b 1/2) b) (log.f64 c)) #s(literal 2 binary64)) (.f64 (fma.f64 (log.f64 y) x z) (.f64 #s(approx (- b 1/2) b) (log.f64 c))))))
(fma.f64 #s(approx (- b 1/2) b) (log.f64 c) (fma.f64 (log.f64 y) x z))
(fma.f64 (log.f64 c) #s(approx (- b 1/2) b) (fma.f64 (log.f64 y) x z))
(fma.f64 (log.f64 y) x (+.f64 z (*.f64 #s(approx (- b 1/2) b) (log.f64 c))))
(fma.f64 x (log.f64 y) (+.f64 z (*.f64 #s(approx (- b 1/2) b) (log.f64 c))))
(-.f64 (fma.f64 (log.f64 y) x z) (*.f64 (neg.f64 (log.f64 c)) #s(approx (- b 1/2) b)))
(+.f64 (*.f64 #s(approx (- b 1/2) b) (log.f64 c)) (fma.f64 (log.f64 y) x z))
(+.f64 (fma.f64 (log.f64 y) x z) (*.f64 #s(approx (- b 1/2) b) (log.f64 c)))
(+.f64 (.f64 (log.f64 y) x) (+.f64 z (.f64 #s(approx (- b 1/2) b) (log.f64 c))))
(/.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)
(*.f64 #s(approx (- b 1/2) b) (log.f64 c))
(*.f64 (log.f64 c) #s(approx (- b 1/2) b))
(log.f64 (pow.f64 c #s(approx (- b 1/2) b)))
#s(approx (- b 1/2) b)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.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) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.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 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))
#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)) (fma.f64 (log.f64 y) x z))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) #s(literal 1 binary64)) a))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (-.f64 (.f64 (log.f64 y) x) (.f64 (neg.f64 a) (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) #s(literal 1 binary64)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (*.f64 (neg.f64 a) (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) #s(literal 1 binary64))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (fma.f64 (neg.f64 a) (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) #s(literal 1 binary64)) (*.f64 (neg.f64 (log.f64 y)) x)))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) #s(literal 1 binary64))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (-.f64 (-.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) a)) #s(literal 1 binary64)) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (-.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)))
#s(approx x x)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.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) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)))
#s(approx (* (log y) x) (*.f64 (log.f64 y) x))
#s(approx (+ (* (log y) x) z) z)
#s(approx (+ (* (log y) x) z) (fma.f64 (log.f64 y) x z))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (*.f64 (log.f64 y) x))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (+.f64 (/.f64 t x) (/.f64 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 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) x) (log.f64 y)) x))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (*.f64 (log.f64 y) x))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (.f64 (fma.f64 a (/.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) #s(literal 1 binary64)) x) (.f64 #s(literal 1 binary64) (log.f64 y))) x))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (*.f64 (neg.f64 (log.f64 y)) x))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (.f64 (.f64 #s(literal -1 binary64) (fma.f64 a (/.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) #s(literal 1 binary64)) x) (log.f64 y))) x))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) a)))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (*.f64 (-.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) #s(literal 1 binary64))) x) (/.f64 (log.f64 y) a)) x))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (neg.f64 (/.f64 (*.f64 (log.f64 y) x) a)))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (*.f64 (-.f64 (/.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) x) (/.f64 (log.f64 y) a)) x))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (/.f64 (*.f64 (log.f64 y) x) a))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (*.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) a) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 (log.f64 y) a)) (/.f64 (/.f64 z a) x)) (/.f64 (/.f64 t a) x)) x))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) x) (log.f64 y)) x))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (log.f64 y) x))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (log.f64 y)) x))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (*.f64 (log.f64 y) x))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.f64 (+.f64 (+.f64 (log.f64 y) (/.f64 a x)) (+.f64 (+.f64 (/.f64 t x) (/.f64 z x)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 i y)) x))) x))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (log.f64 y) x))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) x) (log.f64 y)) x))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (log.f64 y) x))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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 (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (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 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (neg.f64 (.f64 (-.f64 (/.f64 (.f64 (neg.f64 a) (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) #s(literal 1 binary64))) x) (log.f64 y)) x)))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (neg.f64 (*.f64 (fma.f64 a (/.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) #s(literal 1 binary64)) x) (log.f64 y)) x)))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg.f64 (.f64 (-.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) (.f64 a x)) (/.f64 (/.f64 t a) x)) (pow.f64 x #s(literal -1 binary64))) (/.f64 (neg.f64 (log.f64 y)) a)) x)))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (neg.f64 (.f64 (-.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) (.f64 a x)) (/.f64 (/.f64 t a) x)) (/.f64 (neg.f64 (log.f64 y)) a)) x)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) 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) (/.f64 (neg.f64 (log.f64 y)) a)) x)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (neg.f64 (*.f64 (fma.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (neg.f64 (*.f64 (fma.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* (log y) x) z) (neg.f64 (*.f64 (fma.f64 (/.f64 z x) #s(literal -1 binary64) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (* y i) (+ (+ (+ (+ (* 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)) (fma.f64 (log.f64 y) x z))))
#s(approx y y)
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a) #s(literal 1 binary64)) a))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (*.f64 (neg.f64 a) (+.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a) #s(literal 1 binary64))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (+.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a))
#s(approx (log y) (log.f64 y))
#s(approx (+ (* y i) (+ (+ (+ (+ (* 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)) (fma.f64 (log.f64 y) x z))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (*.f64 i y))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (.f64 (log.f64 y) x) a)))) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) a))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (.f64 (neg.f64 a) (+.f64 (+.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (.f64 (log.f64 y) x) a)))) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg.f64 (+.f64 (+.f64 #s(literal 1 binary64) (neg.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) a)))) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (neg.f64 (fma.f64 (neg.f64 (/.f64 (*.f64 (log.f64 y) x) a)) #s(literal -1 binary64) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) 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) (+ (* (log c) (- b 1/2)) z)) t) (+.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)))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x))) z))
#s(approx (log y) (*.f64 #s(literal 1 binary64) (log.f64 y)))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (*.f64 i y))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.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) (+ (* (log c) (- b 1/2)) z)) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x))) z))
#s(approx (* (log y) x) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))
#s(approx (+ (* (log y) x) z) (fma.f64 (*.f64 #s(literal -1 binary64) x) (neg.f64 (log.f64 y)) z))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (+.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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.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 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) a) (/.f64 z a))) a))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (.f64 (neg.f64 a) (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.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 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) a) (/.f64 z a)))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.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 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) a) (/.f64 z a)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (neg.f64 (+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (/.f64 (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) (+ (* (log c) (- b 1/2)) z)) t) a) (/.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) (+ (* (log c) (- b 1/2)) z)) t) (+.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))))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (+.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) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.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) (+ (* (log c) (- b 1/2)) z)) (+.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) (*.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) 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 (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a))
#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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t) a) #s(literal 1 binary64)) a))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (-.f64 z (.f64 (neg.f64 a) (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t) a) #s(literal 1 binary64)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (.f64 (neg.f64 a) (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t) a) #s(literal 1 binary64))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (fma.f64 (neg.f64 a) (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t) a) #s(literal 1 binary64)) (neg.f64 z)))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t) a) #s(literal 1 binary64))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (-.f64 (-.f64 (/.f64 (neg.f64 z) a) #s(literal 1 binary64)) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t) a)))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t) a)))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (-.f64 (/.f64 (neg.f64 z) a) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t) a))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))
#s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (* (log c) (- b 1/2)) z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
#s(approx z z)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) z)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (+.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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) z)
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (.f64 (fma.f64 a (/.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t) a) #s(literal 1 binary64)) z) #s(literal 1 binary64)) z))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (neg.f64 z))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (.f64 (-.f64 (/.f64 (.f64 (neg.f64 a) (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t) a) #s(literal 1 binary64))) z) #s(literal 1 binary64)) z))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (.f64 (-.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t) a) #s(literal 1 binary64))) z) (pow.f64 a #s(literal -1 binary64))) z))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (/.f64 (neg.f64 z) a))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (.f64 (-.f64 (/.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t) a)) z) (pow.f64 a #s(literal -1 binary64))) z))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (/.f64 z a))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) (*.f64 a z)) (/.f64 (/.f64 t a) z)) (pow.f64 a #s(literal -1 binary64))) z))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) z)
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t) z) #s(literal 1 binary64)) z))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) z)
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (.f64 (+.f64 (/.f64 (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 (+ (* (log c) (- b 1/2)) z) z)
#s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 1 binary64)) z))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) z)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) z)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.f64 (+.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 (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) z)
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (.f64 (+.f64 (/.f64 (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 (+ (* (log y) x) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) t) a) z)) #s(literal 1 binary64))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (neg.f64 z) (-.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))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (.f64 (neg.f64 z) (-.f64 (/.f64 (.f64 (neg.f64 a) (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t) a) #s(literal 1 binary64))) z) #s(literal 1 binary64))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (.f64 (neg.f64 z) (fma.f64 a (/.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t) a) #s(literal 1 binary64)) z) #s(literal 1 binary64))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (.f64 (neg.f64 z) (+.f64 (+.f64 (pow.f64 z #s(literal -1 binary64)) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) (*.f64 a z)) (/.f64 (/.f64 t a) z))) (pow.f64 a #s(literal -1 binary64)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (.f64 (neg.f64 z) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) (*.f64 a z)) (/.f64 (/.f64 t a) z)) (pow.f64 a #s(literal -1 binary64)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (.f64 (neg.f64 z) (-.f64 (/.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t) a)) z) (pow.f64 a #s(literal -1 binary64)))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) t) z)) #s(literal 1 binary64))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) z)) #s(literal 1 binary64))))
#s(approx (+ (* (log c) (- b 1/2)) z) (.f64 (neg.f64 z) (-.f64 (neg.f64 (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) #s(literal 1 binary64))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) t) a) z)) #s(literal 1 binary64))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.f64 (neg.f64 z) (-.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))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) z)) #s(literal 1 binary64))))
#s(approx (+ (* (log y) x) z) (.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (.f64 (log.f64 y) x) z)) #s(literal 1 binary64))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.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 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 1 binary64)) a))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (-.f64 t (*.f64 (neg.f64 a) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 1 binary64)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (*.f64 (neg.f64 a) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 1 binary64))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (fma.f64 (neg.f64 a) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 1 binary64)) (neg.f64 t)))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 1 binary64))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (-.f64 (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a)))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a)))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (-.f64 (/.f64 (neg.f64 t) a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)))
#s(approx t t)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a))
#s(approx (+ a t) a)
#s(approx (+ a t) (+.f64 a t))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) t)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (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 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) t) #s(literal 1 binary64)) t))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) t)
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (*.f64 (fma.f64 a (/.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 1 binary64)) t) #s(literal 1 binary64)) t))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (neg.f64 t))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (.f64 (-.f64 (/.f64 (.f64 (neg.f64 a) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 1 binary64))) t) #s(literal 1 binary64)) t))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 t) a))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (*.f64 (-.f64 (/.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 1 binary64))) t) (pow.f64 a #s(literal -1 binary64))) t))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (/.f64 (neg.f64 t) a))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (*.f64 (-.f64 (/.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a)) t) (pow.f64 a #s(literal -1 binary64))) t))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (/.f64 t a))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) (*.f64 a t)) (/.f64 (/.f64 z a) t)) (pow.f64 a #s(literal -1 binary64))) t))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) t)
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) t) #s(literal 1 binary64)) t))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) t)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (log.f64 y) x)) t)) (/.f64 z t))) t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) t)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x 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) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.f64 (neg.f64 t) (-.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))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (neg.f64 t) (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) t)) #s(literal 1 binary64))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (.f64 (neg.f64 t) (-.f64 (/.f64 (.f64 (neg.f64 a) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 1 binary64))) t) #s(literal 1 binary64))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (*.f64 (neg.f64 t) (fma.f64 a (/.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) #s(literal 1 binary64)) t) #s(literal 1 binary64))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (.f64 (neg.f64 t) (+.f64 (+.f64 (pow.f64 t #s(literal -1 binary64)) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) (*.f64 a t)) (/.f64 (/.f64 z a) t))) (pow.f64 a #s(literal -1 binary64)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (.f64 (neg.f64 t) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) (*.f64 a t)) (/.f64 (/.f64 z a) t)) (pow.f64 a #s(literal -1 binary64)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (*.f64 (neg.f64 t) (-.f64 (/.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a)) t) (pow.f64 a #s(literal -1 binary64)))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (*.f64 (neg.f64 t) (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) t)) #s(literal 1 binary64))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.f64 (neg.f64 t) (-.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))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (neg.f64 t) (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) t)) #s(literal 1 binary64))))
#s(approx (+ a t) (*.f64 (neg.f64 t) (-.f64 (/.f64 (neg.f64 a) t) #s(literal 1 binary64))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.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))) (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (-.f64 a (neg.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (neg.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (fma.f64 #s(literal -1 binary64) (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (-.f64 (-.f64 (neg.f64 a) t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z))) a))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)))
#s(approx a a)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) a)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (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 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a) #s(literal 1 binary64)) a))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) a)
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (neg.f64 a))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)) a))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) #s(literal -1 binary64))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64)))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) a)
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (log.f64 y) x)) a)) (/.f64 z a))) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) a)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a) #s(literal 1 binary64)) a))
#s(approx (+ a t) (*.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) a))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.f64 (neg.f64 a) (-.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))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64))))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (*.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.f64 (neg.f64 a) (-.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))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (neg.f64 a) (-.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) (neg.f64 a)) #s(literal 1 binary64))))
#s(approx (+ a t) (*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.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 (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (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 (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 (+.f64 t z) (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x))) a))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64)) a))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (-.f64 (.f64 (log.f64 c) b) (.f64 (neg.f64 a) (+.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64)))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (*.f64 (neg.f64 a) (+.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64))))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (fma.f64 (neg.f64 a) (+.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64)) (neg.f64 (*.f64 (log.f64 c) b))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (-.f64 (-.f64 (/.f64 (neg.f64 (*.f64 (log.f64 c) b)) a) #s(literal 1 binary64)) (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (neg.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a)))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (-.f64 (/.f64 (neg.f64 (*.f64 (log.f64 c) b)) a) (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) b (*.f64 (log.f64 y) x)) a) (/.f64 z a)) (/.f64 t a))))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (* (log c) (- b 1/2)) z) (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z))
#s(approx (+ (* (log c) (- b 1/2)) z) (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) z))
#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) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.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 (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 (log.f64 y) x (*.f64 i y)))) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x))) a))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x)) z))
#s(approx (* (log c) (- b 1/2)) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
#s(approx (* (log c) (- b 1/2)) (*.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b)))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (*.f64 (log.f64 c) b))
#s(approx (+ (* y i) (+ (+ (+ (+ (* 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 (/.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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (*.f64 (log.f64 c) b))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64)) b) (.f64 #s(literal 1 binary64) (log.f64 c))) b))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (neg.f64 (*.f64 (log.f64 c) b)))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (.f64 (.f64 #s(literal -1 binary64) (fma.f64 a (/.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64)) b) (log.f64 c))) b))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 (*.f64 (log.f64 c) b)) a))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (*.f64 (-.f64 (/.f64 (neg.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64))) b) (/.f64 (log.f64 c) a)) b))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (/.f64 (neg.f64 (*.f64 (log.f64 c) b)) a))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (*.f64 (-.f64 (/.f64 (neg.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a)))) b) (/.f64 (log.f64 c) a)) b))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (*.f64 b (/.f64 (log.f64 c) a)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (*.f64 (fma.f64 (/.f64 (/.f64 (log.f64 c) a) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 x a) (/.f64 (log.f64 y) b) (/.f64 (log.f64 c) a)) (/.f64 (/.f64 z a) b)) (/.f64 (/.f64 t a) b))) b))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) b) (/.f64 t b))) b))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (/.f64 (fma.f64 (log.f64 y) x z) b)) b))
#s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (+.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z) b) (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 (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (*.f64 (log.f64 c) b))
#s(approx (+ (* y i) (+ (+ (+ (+ (* 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 (/.f64 (fma.f64 (log.f64 y) x (.f64 i y)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (log.f64 c) b))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.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 (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (/.f64 (fma.f64 (log.f64 y) x z) b)) b))
#s(approx (* (log c) (- b 1/2)) (*.f64 (log.f64 c) b))
#s(approx (* (log c) (- b 1/2)) (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))
#s(approx (+ (* y i) (+ (+ (+ (+ (* 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) (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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (neg.f64 (.f64 (-.f64 (/.f64 (.f64 (neg.f64 a) (+.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64))) b) (log.f64 c)) b)))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (neg.f64 (*.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64)) b) (log.f64 c)) b)))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg.f64 (.f64 (-.f64 (fma.f64 (/.f64 (/.f64 (log.f64 c) a) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) (.f64 b a)) (/.f64 (/.f64 t a) b)) (pow.f64 b #s(literal -1 binary64)))) (/.f64 (neg.f64 (log.f64 c)) a)) b)))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (neg.f64 (.f64 (-.f64 (fma.f64 (/.f64 (/.f64 (log.f64 c) a) b) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) (.f64 b a)) (/.f64 (/.f64 t a) b))) (/.f64 (neg.f64 (log.f64 c)) a)) b)))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (neg.f64 (*.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) b) #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 c)) a)) b)))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 (log.f64 y) x)) z) t) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 (log.f64 y) x)) z) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* (log c) (- b 1/2)) z) (neg.f64 (*.f64 (fma.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z) 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) (+ (+ (+ (+ (* 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) (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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (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 (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 (log.f64 y) x)) z) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (* (log c) (- b 1/2)) (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 (* (log c) (- b 1/2)) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (.f64 #s(literal 1 binary64) (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 (.f64 #s(literal 1 binary64) (log.f64 c)) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) a))
#s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (.f64 (+.f64 (fma.f64 (.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)) #s(literal -1 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64)) a))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (.f64 (neg.f64 a) (+.f64 (fma.f64 (.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)) #s(literal -1 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg.f64 (+.f64 (fma.f64 (*.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)) #s(literal -1 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a))) #s(literal 1 binary64))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (neg.f64 (fma.f64 (*.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)) #s(literal -1 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (/.f64 t a)))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (/.f64 (+.f64 (+.f64 t z) (fma.f64 (.f64 #s(literal 1 binary64) (log.f64 c)) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) a))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (+.f64 (+.f64 t z) (fma.f64 (.f64 #s(literal 1 binary64) (log.f64 c)) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (+.f64 (fma.f64 (.f64 #s(literal 1 binary64) (log.f64 c)) (-.f64 b #s(literal 1/2 binary64)) z) (.f64 (log.f64 y) x)))
#s(approx (+ (* (log c) (- b 1/2)) z) (fma.f64 (*.f64 #s(literal 1 binary64) (log.f64 c)) (-.f64 b #s(literal 1/2 binary64)) z))
#s(approx (log c) (*.f64 #s(literal 1 binary64) (log.f64 c)))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (.f64 #s(literal 1 binary64) (log.f64 c)) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x (.f64 i y)))) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 (+.f64 t z) (fma.f64 (.f64 #s(literal 1 binary64) (log.f64 c)) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) a))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (+.f64 (fma.f64 (.f64 #s(literal 1 binary64) (log.f64 c)) (-.f64 b #s(literal 1/2 binary64)) z) (.f64 (log.f64 y) x)))
#s(approx (* (log c) (- b 1/2)) (.f64 (.f64 #s(literal 1 binary64) (log.f64 c)) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.f64 (+.f64 (+.f64 t z) (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)))) 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 (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 (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a))
#s(approx (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a) (.f64 (neg.f64 a) (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))))))
#s(approx (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (neg.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))))))
#s(approx (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (neg.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) a) (*.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a))))
#s(approx (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (/.f64 (+.f64 (+.f64 t z) (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))) a))
#s(approx (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) (+.f64 (+.f64 t z) (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))))
#s(approx (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (+.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 (+ (* (log c) (- b 1/2)) z) (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)) z))
#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) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (+.f64 (+.f64 (+.f64 t z) (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)))) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.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 (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) (+.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 (* (log c) (- b 1/2)) (*.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) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (.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 (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (*.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z))) i) #s(literal -1 binary64) (neg.f64 y))))
#s(approx (+ (* y i) (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))) (*.f64 (neg.f64 i) (fma.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z))) i) #s(literal -1 binary64) (neg.f64 y))))

eval82.0ms (1.2%)

Memory: 5.3MiB live, 102.3MiB allocated; 15ms collecting garbage
Compiler: Compiled 26 153 to 2 938 computations (88.8% saved)

prune29.0ms (0.4%)

Memory

32.6MiB live, 74.1MiB allocated; 5ms collecting garbage

Pruning

26 alts after pruning (22 fresh and 4 done)

	Pruned	Kept	Total
New	493	9	502
Fresh	1	13	14
Picked	3	2	5
Done	0	2	2
Total	497	26	523

Accuracy

100.0%

Counts

523 → 26

Alt Table

Click to see full alt table

Status	Accuracy	Program
	62.5%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t)))
	36.6%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
	68.0%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x #s(approx (+ ( (log c) (- b 1/2)) z) z)) t) a)) #s(literal 1 binary64)) a))))
	55.9%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 #s(approx (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (*.f64 b (/.f64 (log.f64 c) a)))) #s(literal 1 binary64)) a))))
	66.0%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 #s(approx (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (*.f64 (-.f64 (/.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) x) (/.f64 (log.f64 y) a)) x)) #s(literal 1 binary64)) a))))
	34.9%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
	50.2%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) a)))
✓	44.6%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z))
	50.0%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (/.f64 (-.f64 (.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64))) (log.f64 c))) (*.f64 y i))
▶	65.6%	(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #s(approx (* (- b 1/2) (log c)) (.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))) (.f64 y i))
✓	44.6%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z) (*.f64 y i))
	61.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 #s(approx (+ (* (log y) x) z) z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
▶	63.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
	58.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (log.f64 y)) x))))
	41.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
	47.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
	48.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
	39.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
	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))
▶	73.5%	#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))
▶	13.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
	15.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
▶	25.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
	61.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a) #s(literal 1 binary64)) a)))
✓	21.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
✓	27.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 1 981 to 1 449 computations (26.9% saved)

series466.0ms (7%)

Memory

-17.2MiB live, 587.7MiB allocated; 215ms collecting garbage

Counts

41 → 326

Calls

Call 1

Inputs
#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))
(.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)
(+.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)))
(+.f64 y (/.f64 a i))
y
(/.f64 a i)
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))
(+.f64 (/.f64 t i) (/.f64 z i))
(/.f64 t i)
t
(/.f64 z i)
z
(/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i)
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(*.f64 (log.f64 y) x)
(log.f64 y)
x
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
(*.f64 i y)
#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 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))
(+.f64 a t)
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #s(approx (* (- b 1/2) (log c)) (.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))) (.f64 y i))
(+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #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 (+ (+ (+ (* x (log y)) z) t) a) a)
#s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))
(*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b)
(fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c))
(/.f64 (log.f64 c) b)
#s(literal -1/2 binary64)
(*.f64 y 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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) (* x (log y)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (* (log c) (- b 1/2)) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* x (log y)) (* (log c) (- b 1/2)))))
#s(approx (* (log y) x) #s(hole binary64 (* x (log y))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (* (log c) (- b 1/2)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* 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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* x (+ (log y) (/ (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) x)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ (* x (log y)) i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* x (+ (/ a (* i x)) (+ (/ t (* i x)) (+ (/ y x) (+ (/ z (* i x)) (+ (/ (log y) i) (/ (* (log c) (- b 1/2)) (* i x))))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (/ (* x (log y)) i)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* x (+ (/ t (* i x)) (+ (/ z (* i x)) (+ (/ (log y) i) (/ (* (log c) (- b 1/2)) (* i x))))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (* x (log y)) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (* x (+ (/ (log y) i) (/ (* (log c) (- b 1/2)) (* i x))))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* x (+ (log y) (/ (* (log c) (- b 1/2)) x)))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (+ (log y) (+ (/ z 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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) x)))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) i)) (* -1 (/ (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))) x)))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) i)) (* -1 (/ (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))) x)))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) i)) (* -1 (/ (* (log c) (- b 1/2)) (* i x))))))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* (log c) (- b 1/2)) x)))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ z (* (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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ (* i y) (* i (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
#s(approx (+ y (/ a i)) #s(hole binary64 (/ a i)))
#s(approx (+ y (/ a i)) #s(hole binary64 (+ y (/ a i))))
#s(approx y #s(hole binary64 y))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i)))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx (* i y) #s(hole binary64 (* i 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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i y)))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* y (+ i (/ (* i (+ (* -1 (/ (* x (log (/ 1 y))) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) y)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 y))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* y (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) (* i y))) (+ (/ a (* i y)) (+ (/ t (* i y)) (+ (/ z (* i y)) (/ (* (log c) (- b 1/2)) (* i y))))))))))
#s(approx (+ y (/ a i)) #s(hole binary64 y))
#s(approx (+ y (/ a i)) #s(hole binary64 (* y (+ 1 (/ a (* i y))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (* -1 (/ (* x (log (/ 1 y))) i)) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))) i)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* x (log (/ 1 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 (+ (* -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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (* i (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) i) (/ (* (log c) (- b 1/2)) i)))))) y)))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) i) (/ (* (log c) (- b 1/2)) i))))) y)) 1)))))
#s(approx (+ y (/ a i)) #s(hole binary64 (* -1 (* y (- (* -1 (/ a (* i y))) 1)))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ t i) (+ (/ z i) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) i) (/ (* (log c) (- b 1/2)) i))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))) i)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))
#s(approx (* (log y) x) #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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 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 (+ (* 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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ z (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (/ t i)))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (+ (/ t i) (/ z i))))
#s(approx (/ z i) #s(hole binary64 (/ z i)))
#s(approx z #s(hole binary64 z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ (* x (log y)) (* (log c) (- b 1/2)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* (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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 z))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* z (+ 1 (/ (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) z)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ z i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* z (+ (/ 1 i) (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z))))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (/ z i)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* z (+ (/ 1 i) (+ (/ t (* i z)) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z))))))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (/ z i)))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (* z (+ (/ 1 i) (/ t (* i z))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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) (* (log c) (- b 1/2))) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* z (+ 1 (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* z (+ 1 (/ (* (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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) z)) 1)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))) z)) (/ 1 i))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))) z)) (/ 1 i))))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ t (* i z))) (/ 1 i))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* (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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ t (* i (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))
#s(approx (/ t i) #s(hole binary64 (/ t i)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ a t) #s(hole binary64 a))
#s(approx (+ a t) #s(hole binary64 (+ a t)))
#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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 t))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* t (+ 1 (/ (* i (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) t)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ t i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* t (+ (/ 1 i) (+ (/ a (* i t)) (+ (/ y t) (+ (/ z (* i t)) (+ (/ (* x (log y)) (* i t)) (/ (* (log c) (- b 1/2)) (* i t))))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (/ t i)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* t (+ (/ 1 i) (+ (/ z (* i t)) (+ (/ (* x (log y)) (* i t)) (/ (* (log c) (- b 1/2)) (* i t))))))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (* t (+ (/ 1 i) (/ z (* i t))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) 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))) #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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* t (- (* -1 (/ (* i (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) t)) 1)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))) t)) (/ 1 i))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))) t)) (/ 1 i))))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ z (* i t))) (/ 1 i))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) 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))) #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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ a (* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
#s(approx (/ a i) #s(hole binary64 (/ a i)))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ t (+ z (+ (* 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 (+ (+ (+ (+ (+ (* 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 a))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* a (+ 1 (/ (* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) a)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ a i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* a (+ (/ 1 i) (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i))))))))))
#s(approx (+ y (/ a i)) #s(hole binary64 (* a (+ (/ 1 i) (/ y a)))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) 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))) #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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* a (- (* -1 (/ (* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) a)) 1)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))) a)) (/ 1 i))))))
#s(approx (+ y (/ a i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ y a)) (/ 1 i))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) 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))) #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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i)))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ (* b (log c)) (* i (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* b (log c)) i) (/ (* x (log y)) i)))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (* -1/2 (/ (log c) i)) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (* -1/2 (/ (log c) i)) (+ (/ t i) (+ (/ z i) (+ (/ (* b (log c)) i) (/ (* x (log y)) i)))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* -1/2 (log c)) (* x (log y))) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (+ (* -1/2 (/ (log c) i)) (+ (/ (* b (log c)) i) (/ (* x (log y)) i)))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* -1/2 (log c)) (* x (log y)))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* -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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* -1/2 (log c)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (* b (log c))))))
#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 c) b) -1/2) (log c)) b) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (+ (* (/ (log c) b) -1/2) (log c)) b) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (* -1/2 (/ (log c) b))))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (/ (+ (* -1/2 (log c)) (* b (log c))) b)))
#s(approx (/ (log c) b) #s(hole binary64 (/ (log c) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* b (log c))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* b (+ (log c) (/ (* i (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))) b)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ (* b (log c)) i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* b (+ (* -1/2 (/ (log c) (* b i))) (+ (/ a (* b i)) (+ (/ t (* b i)) (+ (/ y b) (+ (/ z (* b i)) (+ (/ (log c) i) (/ (* x (log y)) (* b i)))))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (/ (* b (log c)) i)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* b (+ (* -1/2 (/ (log c) (* b i))) (+ (/ t (* b i)) (+ (/ z (* b i)) (+ (/ (log c) i) (/ (* x (log y)) (* b i)))))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (* b (log c)) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (* b (+ (* -1/2 (/ (log c) (* b i))) (+ (/ (log c) i) (/ (* x (log y)) (* b i)))))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* x (log y)) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ z 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 c) b) -1/2) (log c)) b) #s(hole binary64 (* b (log c))))
#s(approx (* (+ (* (/ (log c) b) -1/2) (log c)) b) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (log c)))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (+ (log c) (* -1/2 (/ (log c) 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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* i (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))) b)))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (log c) i)) (* -1 (/ (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i)))))) b)))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (log c) i)) (* -1 (/ (+ (* -1/2 (/ (log c) i)) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i)))) b)))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (log c) i)) (* -1 (/ (+ (* -1/2 (/ (log c) i)) (/ (* x (log y)) i)) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* x (log y)))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (* -1/2 (log c))) 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) b) -1/2) (log c)) b) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#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 (+ (+ (+ (+ (+ (* 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) i)) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))) i)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))
#s(approx (log c) #s(hole binary64 (* -1 (log (/ 1 c)))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* -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 (+ (* -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) b) -1/2) (log c)) b) #s(hole binary64 (* b (+ (* -1 (log (/ 1 c))) (* 1/2 (/ (log (/ 1 c)) b))))))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (+ (* -1 (log (/ 1 c))) (* 1/2 (/ (log (/ 1 c)) b)))))
#s(approx (/ (log c) b) #s(hole binary64 (* -1 (/ (log (/ 1 c)) b))))
#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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) i))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) i))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))) i)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* (+ (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) b) -1/2) (log c)) b) #s(hole binary64 (* b (+ (log -1) (+ (* -1 (log (/ -1 c))) (* -1/2 (/ (+ (log -1) (* -1 (log (/ -1 c)))) b)))))))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 c))) (* -1/2 (/ (+ (log -1) (* -1 (log (/ -1 c)))) b))))))
#s(approx (/ (log c) b) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 c)))) b)))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) i)))
#s(approx (+ y (/ a i)) #s(hole binary64 (/ (+ a (* i y)) i)))
#s(approx i #s(hole binary64 i))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (/ (+ t z) 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)))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* i (+ (* -1 y) (+ (* -1 (/ a i)) (+ (* -1 (/ t i)) (+ (* -1 (/ z i)) (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i))))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (+ (* x (log y)) (* (log c) (- b 1/2))))))) i)))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (* -1 (/ (+ (* -1 t) (* -1 z)) i))))

Calls

24 calls:

Time	Variable		Point	Expression
57.0ms	c	@	-inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+ y (/ a i)) y (/ a i) a i (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (+ (/ t i) (/ z i)) (/ t i) t (/ z i) z (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (+ (* (log c) (- b 1/2)) (* (log y) x)) (log c) c (- b 1/2) b 1/2 (* (log y) x) (log y) x (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* i y) (+ (+ (+ (+ (+ (* 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)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+ (* (log c) (- b 1/2)) z) (+ (+ (+ (+ (+ (* 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)) (* (+ (* (/ (log c) b) -1/2) (log c)) b) (+ (* (/ (log c) b) -1/2) (log c)) (/ (log c) b) -1/2 (* y i))
43.0ms	a	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+ y (/ a i)) y (/ a i) a i (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (+ (/ t i) (/ z i)) (/ t i) t (/ z i) z (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (+ (* (log c) (- b 1/2)) (* (log y) x)) (log c) c (- b 1/2) b 1/2 (* (log y) x) (log y) x (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* i y) (+ (+ (+ (+ (+ (* 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)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+ (* (log c) (- b 1/2)) z) (+ (+ (+ (+ (+ (* 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)) (* (+ (* (/ (log c) b) -1/2) (log c)) b) (+ (* (/ (log c) b) -1/2) (log c)) (/ (log c) b) -1/2 (* y i))
38.0ms	z	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+ y (/ a i)) y (/ a i) a i (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (+ (/ t i) (/ z i)) (/ t i) t (/ z i) z (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (+ (* (log c) (- b 1/2)) (* (log y) x)) (log c) c (- b 1/2) b 1/2 (* (log y) x) (log y) x (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* i y) (+ (+ (+ (+ (+ (* 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)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+ (* (log c) (- b 1/2)) z) (+ (+ (+ (+ (+ (* 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)) (* (+ (* (/ (log c) b) -1/2) (log c)) b) (+ (* (/ (log c) b) -1/2) (log c)) (/ (log c) b) -1/2 (* y i))
38.0ms	y	@	0	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+ y (/ a i)) y (/ a i) a i (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (+ (/ t i) (/ z i)) (/ t i) t (/ z i) z (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (+ (* (log c) (- b 1/2)) (* (log y) x)) (log c) c (- b 1/2) b 1/2 (* (log y) x) (log y) x (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* i y) (+ (+ (+ (+ (+ (* 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)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+ (* (log c) (- b 1/2)) z) (+ (+ (+ (+ (+ (* 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)) (* (+ (* (/ (log c) b) -1/2) (log c)) b) (+ (* (/ (log c) b) -1/2) (log c)) (/ (log c) b) -1/2 (* y i))
36.0ms	x	@	inf	((+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+ y (/ a i)) y (/ a i) a i (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (+ (/ t i) (/ z i)) (/ t i) t (/ z i) z (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (+ (* (log c) (- b 1/2)) (* (log y) x)) (log c) c (- b 1/2) b 1/2 (* (log y) x) (log y) x (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* i y) (+ (+ (+ (+ (+ (* 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)) (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+ (* (log c) (- b 1/2)) z) (+ (+ (+ (+ (+ (* 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)) (* (+ (* (/ (log c) b) -1/2) (log c)) b) (+ (* (/ (log c) b) -1/2) (log c)) (/ (log c) b) -1/2 (* y i))

rewrite250.0ms (3.8%)

Memory

26.9MiB live, 212.6MiB allocated; 21ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1111	11384
0	1151	10437
1	7116	10423
0	8373	10107

Stop Event

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

Counts

367 → 473

Calls

Call 1

Inputs
#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))
(.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)
(+.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)))
(+.f64 y (/.f64 a i))
y
(/.f64 a i)
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))
(+.f64 (/.f64 t i) (/.f64 z i))
(/.f64 t i)
t
(/.f64 z i)
z
(/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i)
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(*.f64 (log.f64 y) x)
(log.f64 y)
x
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
(*.f64 i y)
#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 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))
(+.f64 a t)
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #s(approx (* (- b 1/2) (log c)) (.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))) (.f64 y i))
(+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #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 (+ (+ (+ (* x (log y)) z) t) a) a)
#s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))
(*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b)
(fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c))
(/.f64 (log.f64 c) b)
#s(literal -1/2 binary64)
(*.f64 y 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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) (* x (log y)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (* (log c) (- b 1/2)) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* x (log y)) (* (log c) (- b 1/2)))))
#s(approx (* (log y) x) #s(hole binary64 (* x (log y))))
#s(approx x #s(hole binary64 x))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (* (log c) (- b 1/2)))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (* (log c) (- b 1/2)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* 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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* x (log y))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* x (+ (log y) (/ (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) x)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ (* x (log y)) i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* x (+ (/ a (* i x)) (+ (/ t (* i x)) (+ (/ y x) (+ (/ z (* i x)) (+ (/ (log y) i) (/ (* (log c) (- b 1/2)) (* i x))))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (/ (* x (log y)) i)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* x (+ (/ t (* i x)) (+ (/ z (* i x)) (+ (/ (log y) i) (/ (* (log c) (- b 1/2)) (* i x))))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (* x (log y)) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (* x (+ (/ (log y) i) (/ (* (log c) (- b 1/2)) (* i x))))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* x (log y))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* x (+ (log y) (/ (* (log c) (- b 1/2)) x)))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (log y))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* x (+ (log y) (+ (/ z 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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) x)))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) i)) (* -1 (/ (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))) x)))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) i)) (* -1 (/ (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))) x)))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (* -1 (* x (+ (* -1 (/ (log y) i)) (* -1 (/ (* (log c) (- b 1/2)) (* i x))))))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (* (log c) (- b 1/2)) x)))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ z (* (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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ (* i y) (* i (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
#s(approx (+ y (/ a i)) #s(hole binary64 (/ a i)))
#s(approx (+ y (/ a i)) #s(hole binary64 (+ y (/ a i))))
#s(approx y #s(hole binary64 y))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i)))
#s(approx (log y) #s(hole binary64 (log y)))
#s(approx (* i y) #s(hole binary64 (* i 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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i y)))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* y (+ i (/ (* i (+ (* -1 (/ (* x (log (/ 1 y))) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) y)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 y))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* y (+ 1 (+ (* -1 (/ (* x (log (/ 1 y))) (* i y))) (+ (/ a (* i y)) (+ (/ t (* i y)) (+ (/ z (* i y)) (/ (* (log c) (- b 1/2)) (* i y))))))))))
#s(approx (+ y (/ a i)) #s(hole binary64 y))
#s(approx (+ y (/ a i)) #s(hole binary64 (* y (+ 1 (/ a (* i y))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (* -1 (/ (* x (log (/ 1 y))) i)) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))) i)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))
#s(approx (* (log y) x) #s(hole binary64 (* -1 (* x (log (/ 1 y))))))
#s(approx (log y) #s(hole binary64 (* -1 (log (/ 1 y)))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* x (log (/ 1 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 (+ (* -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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* y (+ (* -1 i) (* -1 (/ (* i (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) i) (/ (* (log c) (- b 1/2)) i)))))) y)))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* y (- (* -1 (/ (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) i) (/ (* (log c) (- b 1/2)) i))))) y)) 1)))))
#s(approx (+ y (/ a i)) #s(hole binary64 (* -1 (* y (- (* -1 (/ a (* i y))) 1)))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ t i) (+ (/ z i) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) i) (/ (* (log c) (- b 1/2)) i))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))) i)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))
#s(approx (* (log y) x) #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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 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 (+ (* 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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ z (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (/ t i)))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (+ (/ t i) (/ z i))))
#s(approx (/ z i) #s(hole binary64 (/ z i)))
#s(approx z #s(hole binary64 z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ (* x (log y)) (* (log c) (- b 1/2)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* (log c) (- b 1/2))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* (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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 z))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* z (+ 1 (/ (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) z)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ z i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* z (+ (/ 1 i) (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z))))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (/ z i)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* z (+ (/ 1 i) (+ (/ t (* i z)) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z))))))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (/ z i)))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (* z (+ (/ 1 i) (/ t (* i z))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #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) (* (log c) (- b 1/2))) #s(hole binary64 z))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* z (+ 1 (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 z))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* z (+ 1 (/ (* (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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) z)) 1)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))) z)) (/ 1 i))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))) z)) (/ 1 i))))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (* -1 (* z (- (* -1 (/ t (* i z))) (/ 1 i))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* z (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) z)) 1)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* -1 (* z (- (* -1 (/ (* (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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ t (* i (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))
#s(approx (/ t i) #s(hole binary64 (/ t i)))
#s(approx t #s(hole binary64 t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))))
#s(approx (+ a t) #s(hole binary64 a))
#s(approx (+ a t) #s(hole binary64 (+ a t)))
#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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 t))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* t (+ 1 (/ (* i (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) t)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ t i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* t (+ (/ 1 i) (+ (/ a (* i t)) (+ (/ y t) (+ (/ z (* i t)) (+ (/ (* x (log y)) (* i t)) (/ (* (log c) (- b 1/2)) (* i t))))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (/ t i)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* t (+ (/ 1 i) (+ (/ z (* i t)) (+ (/ (* x (log y)) (* i t)) (/ (* (log c) (- b 1/2)) (* i t))))))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (* t (+ (/ 1 i) (/ z (* i t))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) 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))) #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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* t (- (* -1 (/ (* i (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) t)) 1)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ y (+ (/ a i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))) t)) (/ 1 i))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))) t)) (/ 1 i))))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (* -1 (* t (- (* -1 (/ z (* i t))) (/ 1 i))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) 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))) #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) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ a (* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
#s(approx (/ a i) #s(hole binary64 (/ a i)))
#s(approx a #s(hole binary64 a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ t (+ z (+ (* 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 (+ (+ (+ (+ (+ (* 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 a))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* a (+ 1 (/ (* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) a)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ a i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* a (+ (/ 1 i) (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i))))))))))
#s(approx (+ y (/ a i)) #s(hole binary64 (* a (+ (/ 1 i) (/ y a)))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) 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))) #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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* a (- (* -1 (/ (* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) a)) 1)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))) a)) (/ 1 i))))))
#s(approx (+ y (/ a i)) #s(hole binary64 (* -1 (* a (- (* -1 (/ y a)) (/ 1 i))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) 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))) #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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i)))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ (* b (log c)) (* i (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* b (log c)) i) (/ (* x (log y)) i)))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (* -1/2 (/ (log c) i)) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (* -1/2 (/ (log c) i)) (+ (/ t i) (+ (/ z i) (+ (/ (* b (log c)) i) (/ (* x (log y)) i)))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* -1/2 (log c)) (* x (log y))) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (+ (* -1/2 (/ (log c) i)) (+ (/ (* b (log c)) i) (/ (* x (log y)) i)))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* -1/2 (log c)) (* x (log y)))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* -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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (* x (log y))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* -1/2 (log c)))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (+ (* -1/2 (log c)) (* b (log c))))))
#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 c) b) -1/2) (log c)) b) #s(hole binary64 (* -1/2 (log c))))
#s(approx (* (+ (* (/ (log c) b) -1/2) (log c)) b) #s(hole binary64 (+ (* -1/2 (log c)) (* b (log c)))))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (* -1/2 (/ (log c) b))))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (/ (+ (* -1/2 (log c)) (* b (log c))) b)))
#s(approx (/ (log c) b) #s(hole binary64 (/ (log c) 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* b (log c))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* b (+ (log c) (/ (* i (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))) b)))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ (* b (log c)) i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* b (+ (* -1/2 (/ (log c) (* b i))) (+ (/ a (* b i)) (+ (/ t (* b i)) (+ (/ y b) (+ (/ z (* b i)) (+ (/ (log c) i) (/ (* x (log y)) (* b i)))))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (/ (* b (log c)) i)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* b (+ (* -1/2 (/ (log c) (* b i))) (+ (/ t (* b i)) (+ (/ z (* b i)) (+ (/ (log c) i) (/ (* x (log y)) (* b i)))))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (* b (log c)) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (* b (+ (* -1/2 (/ (log c) (* b i))) (+ (/ (log c) i) (/ (* x (log y)) (* b i)))))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (log c))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* x (log y)) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* b (log c))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ z 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 c) b) -1/2) (log c)) b) #s(hole binary64 (* b (log c))))
#s(approx (* (+ (* (/ (log c) b) -1/2) (log c)) b) #s(hole binary64 (* b (+ (log c) (* -1/2 (/ (log c) b))))))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (log c)))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (+ (log c) (* -1/2 (/ (log c) 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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* i (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))) b)))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (log c) i)) (* -1 (/ (+ y (+ (* -1/2 (/ (log c) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i)))))) b)))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (log c) i)) (* -1 (/ (+ (* -1/2 (/ (log c) i)) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i)))) b)))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (* -1 (* b (+ (* -1 (/ (log c) i)) (* -1 (/ (+ (* -1/2 (/ (log c) i)) (/ (* x (log y)) i)) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ (* -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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* x (log y)))) b)))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (* -1/2 (log c))) 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) b) -1/2) (log c)) b) #s(hole binary64 (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))))
#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 (+ (+ (+ (+ (+ (* 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) i)) (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) i)) (+ (/ t i) (+ (/ z i) (/ (* x (log y)) i))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))) i)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))
#s(approx (log c) #s(hole binary64 (* -1 (log (/ 1 c)))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* -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 (+ (* -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) b) -1/2) (log c)) b) #s(hole binary64 (* b (+ (* -1 (log (/ 1 c))) (* 1/2 (/ (log (/ 1 c)) b))))))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (+ (* -1 (log (/ 1 c))) (* 1/2 (/ (log (/ 1 c)) b)))))
#s(approx (/ (log c) b) #s(hole binary64 (* -1 (/ (log (/ 1 c)) b))))
#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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) i)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) i))))))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) i))))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) #s(hole binary64 (/ (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))) i)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) #s(hole binary64 (+ (* 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(hole binary64 (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
#s(approx (+ (* (log c) (- b 1/2)) z) #s(hole binary64 (+ z (* (+ (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) b) -1/2) (log c)) b) #s(hole binary64 (* b (+ (log -1) (+ (* -1 (log (/ -1 c))) (* -1/2 (/ (+ (log -1) (* -1 (log (/ -1 c)))) b)))))))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) #s(hole binary64 (+ (log -1) (+ (* -1 (log (/ -1 c))) (* -1/2 (/ (+ (log -1) (* -1 (log (/ -1 c)))) b))))))
#s(approx (/ (log c) b) #s(hole binary64 (/ (+ (log -1) (* -1 (log (/ -1 c)))) b)))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (/ (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) i)))
#s(approx (+ y (/ a i)) #s(hole binary64 (/ (+ a (* i y)) i)))
#s(approx i #s(hole binary64 i))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (/ (+ t z) 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)))))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) #s(hole binary64 (* -1 (* i (+ (* -1 y) (+ (* -1 (/ a i)) (+ (* -1 (/ t i)) (+ (* -1 (/ z i)) (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) i))))))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) #s(hole binary64 (+ y (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (+ (* x (log y)) (* (log c) (- b 1/2))))))) i)))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) #s(hole binary64 (* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))
#s(approx (+ (/ t i) (/ z i)) #s(hole binary64 (* -1 (/ (+ (* -1 t) (* -1 z)) i))))

Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 (+.f64 t z) i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i)) i))
(.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 (+.f64 t z) i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i)) i)
(.f64 i (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 (+.f64 t z) i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i)))
(/.f64 (-.f64 (.f64 (.f64 i y) (.f64 i y)) (.f64 (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i))) (-.f64 (.f64 i y) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i)))
(/.f64 (+.f64 (pow.f64 (.f64 i y) #s(literal 3 binary64)) (pow.f64 (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i) #s(literal 3 binary64))) (fma.f64 (.f64 i y) (.f64 i y) (-.f64 (.f64 (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i)) (.f64 (.f64 i y) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i)))))
(fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i (.f64 i y))
(fma.f64 i (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) (.f64 i y))
(fma.f64 i y (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i))
(fma.f64 y i (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i))
(-.f64 (.f64 i y) (.f64 (neg.f64 i) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i))))
(+.f64 (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i) (*.f64 i y))
(+.f64 (.f64 i y) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i))
(/.f64 (-.f64 (.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 a i) y)) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)))) (-.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i))))
(/.f64 (-.f64 (.f64 y y) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)))) (-.f64 y (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i))))
(/.f64 (+.f64 (pow.f64 (+.f64 (/.f64 a i) y) #s(literal 3 binary64)) (pow.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) #s(literal 3 binary64))) (fma.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 a i) y) (-.f64 (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i))) (.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i))))))
(/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i))) (.f64 y (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i))))))
(+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 (+.f64 t z) i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) y)
(+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (+.f64 (/.f64 a i) y))
(+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)))
(+.f64 y (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)))
(/.f64 (-.f64 (.f64 y y) (.f64 (/.f64 a i) (/.f64 a i))) (-.f64 y (/.f64 a i)))
(/.f64 (+.f64 (pow.f64 y #s(literal 3 binary64)) (pow.f64 (/.f64 a i) #s(literal 3 binary64))) (fma.f64 y y (-.f64 (.f64 (/.f64 a i) (/.f64 a i)) (.f64 y (/.f64 a i)))))
(+.f64 (/.f64 a i) y)
(+.f64 y (/.f64 a i))
y
(/.f64 (neg.f64 a) (neg.f64 i))
(/.f64 a i)
a
i
(/.f64 (-.f64 (.f64 (/.f64 (+.f64 t z) i) (/.f64 (+.f64 t z) i)) (.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i))) (-.f64 (/.f64 (+.f64 t z) i) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i)))
(/.f64 (-.f64 (.f64 (/.f64 t i) (/.f64 t i)) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))))) (-.f64 (/.f64 t i) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))))
(/.f64 (+.f64 (pow.f64 (/.f64 (+.f64 t z) i) #s(literal 3 binary64)) (pow.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) #s(literal 3 binary64))) (fma.f64 (/.f64 (+.f64 t z) i) (/.f64 (+.f64 t z) i) (-.f64 (.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i)) (.f64 (/.f64 (+.f64 t z) i) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i)))))
(/.f64 (+.f64 (pow.f64 (/.f64 t i) #s(literal 3 binary64)) (pow.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) #s(literal 3 binary64))) (fma.f64 (/.f64 t i) (/.f64 t i) (-.f64 (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))) (.f64 (/.f64 t i) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))))))
(+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 t i))
(+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i))
(+.f64 (/.f64 (+.f64 t z) i) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i))
(+.f64 (/.f64 t i) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))))
(/.f64 (-.f64 (.f64 (/.f64 t i) (/.f64 t i)) (.f64 (/.f64 z i) (/.f64 z i))) (-.f64 (/.f64 t i) (/.f64 z i)))
(/.f64 (+.f64 (pow.f64 (/.f64 t i) #s(literal 3 binary64)) (pow.f64 (/.f64 z i) #s(literal 3 binary64))) (fma.f64 (/.f64 t i) (/.f64 t i) (-.f64 (.f64 (/.f64 z i) (/.f64 z i)) (.f64 (/.f64 t i) (/.f64 z i)))))
(/.f64 (neg.f64 (+.f64 t z)) (neg.f64 i))
(/.f64 (fma.f64 i t (.f64 i z)) (.f64 i i))
(/.f64 (+.f64 t z) i)
(+.f64 (/.f64 z i) (/.f64 t i))
(+.f64 (/.f64 t i) (/.f64 z i))
(/.f64 (neg.f64 t) (neg.f64 i))
(/.f64 t i)
t
(/.f64 (neg.f64 z) (neg.f64 i))
(/.f64 z i)
z
(/.f64 (-.f64 (.f64 (/.f64 (.f64 (log.f64 y) x) i) (/.f64 (.f64 (log.f64 y) x) i)) (.f64 (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))) (-.f64 (/.f64 (.f64 (log.f64 y) x) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))))
(/.f64 (+.f64 (pow.f64 (/.f64 (.f64 (log.f64 y) x) i) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)) #s(literal 3 binary64))) (fma.f64 (/.f64 (.f64 (log.f64 y) x) i) (/.f64 (.f64 (log.f64 y) x) i) (-.f64 (.f64 (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (.f64 (/.f64 (.f64 (log.f64 y) x) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))))))
(/.f64 (fma.f64 (.f64 (log.f64 y) x) i (log.f64 (pow.f64 (pow.f64 c (-.f64 b #s(literal 1/2 binary64))) i))) (.f64 i i))
(/.f64 (neg.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) (neg.f64 i))
(/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i)
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (/.f64 (*.f64 (log.f64 y) x) i))
(fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))
(+.f64 (/.f64 (.f64 (log.f64 y) x) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))
(+.f64 (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)) (/.f64 (.f64 (log.f64 y) x) i))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (.f64 (log.f64 y) x) (.f64 (log.f64 y) x))) (log.f64 (/.f64 (pow.f64 c (-.f64 b #s(literal 1/2 binary64))) (pow.f64 y x))))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 y) x) (.f64 (log.f64 y) x)) (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) (log.f64 (/.f64 (pow.f64 y x) (pow.f64 c (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (-.f64 (.f64 (.f64 (log.f64 y) x) (.f64 (log.f64 y) x)) (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (.f64 (log.f64 y) x)))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 y) x) #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 (.f64 (log.f64 y) x) (.f64 (log.f64 y) x) (-.f64 (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 (.f64 (log.f64 y) x) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 (log.f64 y) x))
(fma.f64 (log.f64 y) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 x (log.f64 y) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(-.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (.f64 (neg.f64 (log.f64 y)) x))
(-.f64 (.f64 (log.f64 y) x) (.f64 (neg.f64 (log.f64 c)) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (.f64 (log.f64 y) x))
(+.f64 (.f64 (log.f64 y) x) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(log.f64 (/.f64 (pow.f64 c (-.f64 b #s(literal 1/2 binary64))) (pow.f64 (pow.f64 y #s(literal -1 binary64)) x)))
(log.f64 (*.f64 (pow.f64 c (-.f64 b #s(literal 1/2 binary64))) (pow.f64 y x)))
(log.f64 (*.f64 (pow.f64 y x) (pow.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 (log.f64 y) x)
(*.f64 x (log.f64 y))
(log.f64 (pow.f64 y x))
(log.f64 y)
x
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
(*.f64 i y)
(*.f64 y i)
#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 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(/.f64 (-.f64 (.f64 (+.f64 a t) (+.f64 a t)) (.f64 #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))) (-.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(/.f64 (+.f64 (pow.f64 (+.f64 a t) #s(literal 3 binary64)) (pow.f64 #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) #s(literal 3 binary64))) (fma.f64 (+.f64 a t) (+.f64 a t) (-.f64 (.f64 #s(approx (+ (+ ( (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))) (.f64 (+.f64 a t) #s(approx (+ (+ ( (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))))
(+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))
(+.f64 #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) (+.f64 a t))
(+.f64 a (+.f64 t #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(/.f64 (-.f64 (.f64 a a) (.f64 t t)) (-.f64 a t))
(/.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)
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
(/.f64 (-.f64 (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (.f64 z z)) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z))
(/.f64 (-.f64 (.f64 z z) (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) (-.f64 z (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)) (pow.f64 z #s(literal 3 binary64))) (fma.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (-.f64 (.f64 z z) (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z))))
(/.f64 (+.f64 (pow.f64 z #s(literal 3 binary64)) (pow.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (.f64 (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (log.f64 (pow.f64 (pow.f64 c (-.f64 b #s(literal 1/2 binary64))) z)))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)
(-.f64 z (*.f64 (neg.f64 (log.f64 c)) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z)
(+.f64 z (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(/.f64 (-.f64 (.f64 (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a)) (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a))) (.f64 (.f64 i y) (.f64 i y))) (-.f64 (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a)) (*.f64 i y)))
(/.f64 (+.f64 (pow.f64 (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a)) #s(literal 3 binary64)) (pow.f64 (.f64 i y) #s(literal 3 binary64))) (fma.f64 (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a)) (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a)) (-.f64 (.f64 (.f64 i y) (.f64 i y)) (.f64 (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a)) (*.f64 i y)))))
(fma.f64 i y (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a)))
(fma.f64 y i (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a)))
(-.f64 (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a)) (*.f64 (neg.f64 y) i))
(+.f64 (.f64 i y) (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a)))
(+.f64 (+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a)) (*.f64 i y))
(+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (+.f64 #s(approx (* (- b 1/2) (log c)) (.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b)) (.f64 i y)))
(/.f64 (-.f64 (.f64 #s(approx (+ (+ (+ ( x (log y)) z) t) a) a) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a)) (.f64 #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) (log c)) (.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b)))) (-.f64 #s(approx (+ (+ (+ ( x (log y)) z) t) a) a) #s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))))
(/.f64 (+.f64 (pow.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #s(literal 3 binary64)) (pow.f64 #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(literal 3 binary64))) (fma.f64 #s(approx (+ (+ (+ ( x (log y)) z) t) a) a) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (-.f64 (.f64 #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) (log c)) (.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))) (.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))))))
(+.f64 #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 (+ (+ (+ ( x (log y)) z) t) a) a))
(+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #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 (+ (+ (+ (* x (log y)) z) t) a) a)
#s(approx (* (- b 1/2) (log c)) (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))
(*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b)
(*.f64 b (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)))
(fma.f64 (log.f64 c) b (.f64 (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) b))
(fma.f64 (log.f64 c) b (.f64 b (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64))))
(fma.f64 b (log.f64 c) (.f64 (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) b))
(fma.f64 b (log.f64 c) (.f64 b (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64))))
(+.f64 (.f64 (log.f64 c) b) (.f64 (*.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) b))
(+.f64 (.f64 (log.f64 c) b) (.f64 b (*.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64))))
(/.f64 (-.f64 (.f64 (log.f64 c) (log.f64 c)) (.f64 (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)))) (-.f64 (log.f64 c) (*.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64))))
(/.f64 (-.f64 (.f64 (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64))) (.f64 (log.f64 c) (log.f64 c))) (-.f64 (*.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) (log.f64 c)))
(/.f64 (+.f64 (pow.f64 (log.f64 c) #s(literal 3 binary64)) (pow.f64 (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (fma.f64 (log.f64 c) (log.f64 c) (-.f64 (.f64 (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64))) (.f64 (log.f64 c) (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64))))))
(/.f64 (+.f64 (pow.f64 (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 c) #s(literal 3 binary64))) (fma.f64 (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) (-.f64 (.f64 (log.f64 c) (log.f64 c)) (.f64 (.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) (log.f64 c)))))
(fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c))
(fma.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 c) b) (log.f64 c))
(-.f64 (log.f64 c) (*.f64 (/.f64 (log.f64 c) b) #s(literal 1/2 binary64)))
(+.f64 (*.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)) (log.f64 c))
(+.f64 (log.f64 c) (*.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)))
(/.f64 (neg.f64 (log.f64 c)) (neg.f64 b))
(/.f64 (log.f64 c) b)
#s(literal -1/2 binary64)
(*.f64 i y)
(*.f64 y 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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (*.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i))) i))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (fma.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i))) i (*.f64 (log.f64 y) x)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 (+.f64 t z) i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))
#s(approx (* (log y) x) (*.f64 (log.f64 y) x))
#s(approx x x)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a)))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a)))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (+.f64 t z) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a))
#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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (*.f64 (log.f64 y) x))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (*.f64 (fma.f64 i (/.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i))) x) (log.f64 y)) x))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 (*.f64 (log.f64 y) x) i))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) i) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 (log.f64 y) i)) (/.f64 (/.f64 z i) x)) (/.f64 y x)) (/.f64 (/.f64 t i) x)) (/.f64 (/.f64 a i) x)) x))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 (*.f64 (log.f64 y) x) i))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (*.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) i) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 (log.f64 y) i)) (/.f64 (/.f64 z i) x)) (/.f64 (/.f64 t i) x)) x))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (/.f64 (*.f64 (log.f64 y) x) i))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (*.f64 (fma.f64 (/.f64 (log.f64 c) i) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 (log.f64 y) i)) x))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (*.f64 (log.f64 y) x))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 y)) x))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (log.f64 y) x))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.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) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (log.f64 y)) x))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (log.f64 y) x))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.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) 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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (neg.f64 (.f64 (.f64 #s(literal -1 binary64) (fma.f64 i (/.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i))) x) (log.f64 y))) x)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i))) x) #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 y)) i)) x)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i)) x) #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 y)) i)) x)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (neg.f64 (.f64 (.f64 #s(literal -1 binary64) (fma.f64 (/.f64 (log.f64 c) i) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 (log.f64 y) i))) x)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (neg.f64 (.f64 (.f64 #s(literal -1 binary64) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 y))) x)))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (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) (* (log c) (- b 1/2))) (neg.f64 (*.f64 (fma.f64 #s(literal -1 binary64) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (neg.f64 (log.f64 y))) x)))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (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) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a)))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)) i))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 (+.f64 t z) i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i)) i))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) (/.f64 a i)))
#s(approx (+ y (/ a i)) (/.f64 a i))
#s(approx (+ y (/ a i)) (+.f64 (/.f64 a i) y))
#s(approx y y)
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i))
#s(approx (log y) (log.f64 y))
#s(approx (* i y) (*.f64 i y))
#s(approx (* i y) (*.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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (*.f64 i y))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (fma.f64 i (/.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) i)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i)) (/.f64 a i))) y) i) y))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) y)
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) i)) y))) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) (*.f64 i y)) (/.f64 (/.f64 t i) y)) (/.f64 (/.f64 a i) y))) y))
#s(approx (+ y (/ a i)) y)
#s(approx (+ y (/ a i)) (*.f64 (+.f64 (/.f64 (/.f64 a i) y) #s(literal 1 binary64)) y))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (fma.f64 (*.f64 x (/.f64 (neg.f64 (log.f64 y)) i)) #s(literal -1 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x))) i))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x))))
#s(approx (* (log y) x) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x)))
#s(approx (log y) (neg.f64 (neg.f64 (log.f64 y))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.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) (* (log c) (- b 1/2))) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 (*.f64 (neg.f64 (log.f64 y)) x))) z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.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) a) (* (- b 1/2) (log c))) (* y i)) (.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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (neg.f64 y) (fma.f64 (.f64 i (/.f64 (+.f64 (+.f64 (/.f64 (+.f64 t z) i) (/.f64 (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)))) i)) (/.f64 a i)) y)) #s(literal -1 binary64) (neg.f64 i))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (.f64 (neg.f64 y) (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 (/.f64 (+.f64 t z) i) (/.f64 (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)))) i)) (/.f64 a i)) y)) #s(literal 1 binary64))))
#s(approx (+ y (/ a i)) (.f64 (neg.f64 y) (-.f64 (/.f64 (neg.f64 a) (.f64 i y)) #s(literal 1 binary64))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (+.f64 (/.f64 (+.f64 t z) i) (/.f64 (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)))) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (/.f64 (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)))) i))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (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)))))
#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 (log y) (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) y)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.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) (* (log c) (- b 1/2))) (+.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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.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 (+ (+ (+ (* 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) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) (/.f64 t i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i)) y) i))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (fma.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) (/.f64 t i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i)) y) i z))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+.f64 (+.f64 (+.f64 (/.f64 a i) (/.f64 t i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i)) y))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 t i)))
#s(approx (+ (/ t i) (/ z i)) (/.f64 t i))
#s(approx (+ (/ t i) (/ z i)) (/.f64 (+.f64 t z) i))
#s(approx (/ z i) (/.f64 z i))
#s(approx z z)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))
#s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (* (log c) (- b 1/2)) z) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.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) 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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) z)
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (fma.f64 i (/.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) (/.f64 t i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i)) y) z) #s(literal 1 binary64)) z))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (.f64 (+.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) (*.f64 i z)) (/.f64 y z)) (/.f64 (/.f64 t i) z)) (/.f64 (/.f64 a i) z)) (pow.f64 i #s(literal -1 binary64))) z))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) (*.f64 i z)) (/.f64 (/.f64 t i) z)) (pow.f64 i #s(literal -1 binary64))) z))
#s(approx (+ (/ t i) (/ z i)) (/.f64 z i))
#s(approx (+ (/ t i) (/ z i)) (*.f64 (+.f64 (/.f64 (/.f64 t i) z) (pow.f64 i #s(literal -1 binary64))) z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) z)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.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 (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (.f64 (+.f64 (/.f64 (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 (+ (* (log c) (- b 1/2)) z) z)
#s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 1 binary64)) z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) z)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.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) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x))) t) a) z)) #s(literal 1 binary64))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (neg.f64 z) (-.f64 (neg.f64 (.f64 i (/.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) (/.f64 t i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i)) y) z))) #s(literal 1 binary64))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) (/.f64 t i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i)) y) z)) (pow.f64 i #s(literal -1 binary64)))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 t i)) z)) (pow.f64 i #s(literal -1 binary64)))))
#s(approx (+ (/ t i) (/ z i)) (.f64 (neg.f64 z) (-.f64 (/.f64 (neg.f64 t) (.f64 i z)) (pow.f64 i #s(literal -1 binary64)))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.f64 (neg.f64 z) (-.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))))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) z)) #s(literal 1 binary64))))
#s(approx (+ (* (log c) (- b 1/2)) z) (.f64 (neg.f64 z) (-.f64 (neg.f64 (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) #s(literal 1 binary64))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.f64 (neg.f64 z) (-.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))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (neg.f64 z) (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z)) #s(literal 1 binary64))))
#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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))) i))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (fma.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))) i t))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))))
#s(approx (/ t i) (/.f64 t i))
#s(approx t t)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a))
#s(approx (+ a t) a)
#s(approx (+ a t) (+.f64 a t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (+.f64 (fma.f64 (log.f64 y) x z) 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)) (.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 (log.f64 y) x)) t)) (/.f64 z t))) t))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) t)
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (fma.f64 i (/.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))) t) #s(literal 1 binary64)) t))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 t i))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (.f64 (+.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) (*.f64 i t)) (/.f64 (/.f64 z i) t)) (/.f64 y t)) (/.f64 (/.f64 a i) t)) (pow.f64 i #s(literal -1 binary64))) t))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 t i))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) (*.f64 i t)) (/.f64 (/.f64 z i) t)) (pow.f64 i #s(literal -1 binary64))) t))
#s(approx (+ (/ t i) (/ z i)) (*.f64 (+.f64 (/.f64 (/.f64 z i) t) (pow.f64 i #s(literal -1 binary64))) t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) t)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.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 (+ a t) t)
#s(approx (+ a t) (*.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) t)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.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) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (neg.f64 t) (-.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))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (neg.f64 t) (-.f64 (neg.f64 (.f64 i (/.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))) t))) #s(literal 1 binary64))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (.f64 (neg.f64 t) (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))) t)) (pow.f64 i #s(literal -1 binary64)))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (.f64 (neg.f64 t) (-.f64 (neg.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) t)) (pow.f64 i #s(literal -1 binary64)))))
#s(approx (+ (/ t i) (/ z i)) (.f64 (neg.f64 t) (-.f64 (/.f64 (neg.f64 z) (.f64 i t)) (pow.f64 i #s(literal -1 binary64)))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (neg.f64 t) (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) t)) #s(literal 1 binary64))))
#s(approx (+ a t) (*.f64 (neg.f64 t) (-.f64 (/.f64 (neg.f64 a) t) #s(literal 1 binary64))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (neg.f64 t) (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) a) t)) #s(literal 1 binary64))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (neg.f64 t) (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) a) t)) #s(literal 1 binary64))))
#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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) y) i))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) y) i a))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) y))
#s(approx (/ a i) (/.f64 a i))
#s(approx a a)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) t))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) t))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (fma.f64 (log.f64 y) x (+.f64 t 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 (+.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 (log.f64 y) x)) a)) (/.f64 z a))) a))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) a)
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (fma.f64 i (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) y) a) #s(literal 1 binary64)) a))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 a i))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (.f64 (+.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) (*.f64 i a)) (/.f64 (/.f64 z a) i)) (/.f64 y a)) (/.f64 (/.f64 t a) i)) (pow.f64 i #s(literal -1 binary64))) a))
#s(approx (+ y (/ a i)) (*.f64 (+.f64 (/.f64 y a) (pow.f64 i #s(literal -1 binary64))) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) a)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.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 (+ a t) (*.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) a)
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.f64 (+.f64 (+.f64 (/.f64 t a) #s(literal 1 binary64)) (+.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)) (.f64 (neg.f64 a) (-.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))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (neg.f64 a) (-.f64 (neg.f64 (.f64 i (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) y) a))) #s(literal 1 binary64))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (.f64 (neg.f64 a) (-.f64 (neg.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i) (/.f64 (+.f64 t z) i)) y) a)) (pow.f64 i #s(literal -1 binary64)))))
#s(approx (+ y (/ a i)) (*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 y) a) (pow.f64 i #s(literal -1 binary64)))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (neg.f64 a) (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) t) a)) #s(literal 1 binary64))))
#s(approx (+ a t) (*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (neg.f64 a) (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) t) a)) #s(literal 1 binary64))))
#s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (neg.f64 a) (-.f64 (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a)) #s(literal 1 binary64))))
#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 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) i) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (/.f64 t i)) (/.f64 a i))) y) i))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (fma.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) i) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (/.f64 t i)) (/.f64 a i))) y) i (*.f64 (log.f64 c) b)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+.f64 (fma.f64 (/.f64 (log.f64 c) i) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (/.f64 t i)) (/.f64 a i))) y))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+.f64 (fma.f64 (/.f64 (log.f64 c) i) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (+.f64 t z) i) (/.f64 (fma.f64 (log.f64 c) b (*.f64 (log.f64 y) x)) i)) (/.f64 a i))) y))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (fma.f64 (/.f64 (log.f64 c) i) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (/.f64 t i))))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (fma.f64 (/.f64 (log.f64 c) i) #s(literal -1/2 binary64) (+.f64 (/.f64 (+.f64 t z) i) (/.f64 (fma.f64 (log.f64 c) b (*.f64 (log.f64 y) x)) i))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) i))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (fma.f64 (/.f64 (log.f64 c) i) #s(literal -1/2 binary64) (/.f64 (fma.f64 (log.f64 c) b (*.f64 (log.f64 y) x)) i)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x)))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x)) z) t) a))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (* (log c) (- b 1/2)) z) (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z))
#s(approx (+ (* (log c) (- b 1/2)) z) (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (*.f64 (log.f64 y) x)) 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 (* (+ (* (/ (log c) b) -1/2) (log c)) b) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
#s(approx (* (+ (* (/ (log c) b) -1/2) (log c)) b) (*.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b)))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) (*.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64)))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) (/.f64 (*.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b)) b))
#s(approx (/ (log c) b) (/.f64 (log.f64 c) 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) (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 i y (.f64 (log.f64 y) x)) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (*.f64 (log.f64 c) b))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (*.f64 (fma.f64 i (/.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) i) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (/.f64 t i)) (/.f64 a i))) y) b) (log.f64 c)) b))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (*.f64 b (/.f64 (log.f64 c) i)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (*.f64 (fma.f64 (/.f64 (/.f64 (log.f64 c) b) i) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 x b) (/.f64 (log.f64 y) i) (/.f64 (log.f64 c) i)) (/.f64 (/.f64 z b) i)) (/.f64 y b)) (/.f64 (/.f64 t b) i)) (/.f64 (/.f64 a b) i))) b))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (*.f64 b (/.f64 (log.f64 c) i)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (*.f64 (fma.f64 (/.f64 (/.f64 (log.f64 c) b) i) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 x b) (/.f64 (log.f64 y) i) (/.f64 (log.f64 c) i)) (/.f64 (/.f64 z b) i)) (/.f64 (/.f64 t b) i))) b))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (*.f64 b (/.f64 (log.f64 c) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (*.f64 (fma.f64 (/.f64 (/.f64 (log.f64 c) b) i) #s(literal -1/2 binary64) (fma.f64 (/.f64 x b) (/.f64 (log.f64 y) i) (/.f64 (log.f64 c) i))) b))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (.f64 (+.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 (log.f64 y) x)) b) (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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (log.f64 c) b))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) b) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (/.f64 (fma.f64 (log.f64 y) x z) b)) (log.f64 c)) b))
#s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (log.f64 c) b))
#s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (+.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z) b) (log.f64 c)) b))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (log.f64 c) b))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) b) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) 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 (* (+ (* (/ (log c) b) -1/2) (log c)) b) (*.f64 (log.f64 c) b))
#s(approx (* (+ (* (/ (log c) b) -1/2) (log c)) b) (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) (log.f64 c))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)))
#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 (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (neg.f64 (.f64 (.f64 #s(literal -1 binary64) (fma.f64 i (/.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) i) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (/.f64 t i)) (/.f64 a i))) y) b) (log.f64 c))) b)))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (neg.f64 (*.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) i) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (/.f64 t i)) (/.f64 a i))) y) b) #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 c)) i)) b)))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (neg.f64 (*.f64 (fma.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) i) #s(literal -1/2 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (/.f64 t i))) b) #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 c)) i)) b)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (neg.f64 (.f64 (fma.f64 (/.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 (log.f64 y) x)) i) b) #s(literal -1 binary64) (/.f64 (neg.f64 (log.f64 c)) i)) b)))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (neg.f64 (.f64 (fma.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 (log.f64 y) x)) 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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (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 (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (neg.f64 (.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (.f64 (log.f64 y) x)) z) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (* (log c) (- b 1/2)) z) (neg.f64 (*.f64 (fma.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z) b) #s(literal -1 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (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 (* (+ (* (/ (log c) b) -1/2) (log c)) b) (neg.f64 (*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal 1/2 binary64) (neg.f64 (log.f64 c))) b)))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 (+.f64 t z) i)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (.f64 (log.f64 y) x)) i)) i))
#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 (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 (+.f64 (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) z) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (+.f64 (fma.f64 (.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (/.f64 t i)) (/.f64 a i))) y) i))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+.f64 (fma.f64 (*.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (/.f64 t i)) (/.f64 a i))) y))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (fma.f64 (*.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)) #s(literal -1 binary64) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (/.f64 t i))))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (/.f64 (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)))
#s(approx (log c) (neg.f64 (neg.f64 (log.f64 c))))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 (+.f64 (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) z) (*.f64 (log.f64 y) x)) t) a))
#s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+.f64 (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) z) (*.f64 (log.f64 y) x)))
#s(approx (+ (* (log c) (- b 1/2)) z) (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.f64 (+.f64 (+.f64 (fma.f64 (neg.f64 (neg.f64 (log.f64 c))) (-.f64 b #s(literal 1/2 binary64)) z) (*.f64 (log.f64 y) x)) t) 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) b) -1/2) (log c)) b) (*.f64 (fma.f64 (/.f64 (neg.f64 (log.f64 c)) b) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 c)))) b))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) (fma.f64 (/.f64 (neg.f64 (log.f64 c)) b) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 c)))))
#s(approx (/ (log c) b) (/.f64 (neg.f64 (neg.f64 (log.f64 c))) b))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.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 (log.f64 y) x))) z) t) a))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (+.f64 (+.f64 (+.f64 (/.f64 (+.f64 t z) i) (/.f64 (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)) i)) (/.f64 a i)) y) i))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (+.f64 (+.f64 (+.f64 (/.f64 (+.f64 t z) i) (/.f64 (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)) i)) (/.f64 a i)) y))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (+.f64 (/.f64 (+.f64 t z) i) (/.f64 (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)) i)))
#s(approx (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i) (/.f64 (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)) i))
#s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (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)))
#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 (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.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 (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (+.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 (+ (* (log c) (- b 1/2)) z) (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)) z))
#s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (+.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) b) -1/2) (log c)) b) (*.f64 (+.f64 (fma.f64 (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) b) #s(literal -1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)))) (log.f64 #s(literal -1 binary64))) b))
#s(approx (+ (* (/ (log c) b) -1/2) (log c)) (+.f64 (fma.f64 (/.f64 (fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64))) b) #s(literal -1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) c)))) (log.f64 #s(literal -1 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 (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a)))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) 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 (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a)) i))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 (+.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)) i))
#s(approx (+ y (/ a i)) (/.f64 (fma.f64 i y a) i))
#s(approx i i)
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) t) i))
#s(approx (+ (/ t i) (/ z i)) (/.f64 (+.f64 t z) i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 (+.f64 t 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 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (fma.f64 (log.f64 y) x (+.f64 t z)) a)) i) #s(literal -1 binary64) (neg.f64 y))))
#s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (neg.f64 i) (+.f64 (fma.f64 #s(literal -1 binary64) y (/.f64 (neg.f64 a) i)) (+.f64 (/.f64 (.f64 #s(literal -1 binary64) (+.f64 t z)) i) (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) i))))))
#s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) (fma.f64 (/.f64 (+.f64 (neg.f64 a) (fma.f64 #s(literal -1 binary64) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) (neg.f64 t))) i) #s(literal -1 binary64) y))
#s(approx (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i)) (neg.f64 (/.f64 (fma.f64 #s(literal -1 binary64) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x z)) (neg.f64 t)) i)))
#s(approx (+ (/ t i) (/ z i)) (neg.f64 (/.f64 (*.f64 #s(literal -1 binary64) (+.f64 t z)) i)))

eval71.0ms (1.1%)

Memory: -4.1MiB live, 133.6MiB allocated; 28ms collecting garbage
Compiler: Compiled 28 269 to 2 450 computations (91.3% saved)

prune49.0ms (0.7%)

Memory

5.1MiB live, 108.2MiB allocated; 15ms collecting garbage

Pruning

31 alts after pruning (25 fresh and 6 done)

	Pruned	Kept	Total
New	496	12	508
Fresh	4	13	17
Picked	3	2	5
Done	0	4	4
Total	503	31	534

Accuracy

100.0%

Counts

534 → 31

Alt Table

Click to see full alt table

Status	Accuracy	Program
	36.6%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
	68.0%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x #s(approx (+ ( (log c) (- b 1/2)) z) z)) t) a)) #s(literal 1 binary64)) a))))
	55.9%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 #s(approx (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (*.f64 b (/.f64 (log.f64 c) a)))) #s(literal 1 binary64)) a))))
	66.0%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 #s(approx (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (*.f64 (-.f64 (/.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) x) (/.f64 (log.f64 y) a)) x)) #s(literal 1 binary64)) a))))
	34.9%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
	50.2%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) a)))
✓	44.6%	(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z))
✓	44.6%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z) (*.f64 y i))
	49.2%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (/.f64 (-.f64 (*.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64))) z))))
	58.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (log.f64 y)) x))))
	41.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
	58.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 1 binary64)) z)))))
	47.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
	48.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
	63.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
	39.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
	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))
	62.9%	#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 #s(approx (+ ( (log c) (- b 1/2)) (* (log y) x)) (*.f64 (log.f64 y) x)) i))) i))
	65.5%	#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)) #s(approx (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))))) i))
	55.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))
✓	13.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
	15.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
	14.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i)) i))
	60.2%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) i)) y))) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) (*.f64 i y)) (/.f64 (/.f64 t i) y)) (/.f64 (/.f64 a i) y))) y)) i))
✓	25.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
	61.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a) #s(literal 1 binary64)) a)))
	49.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t)))
	50.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (fma.f64 i (/.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) i)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i)) (/.f64 a i))) y) i) y)))
	47.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (fma.f64 i (/.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))) t) #s(literal 1 binary64)) t)))
✓	21.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
✓	27.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 3 801 to 1 365 computations (64.1% saved)

regimes279.0ms (4.2%)

Memory

5.5MiB live, 257.3MiB allocated; 166ms collecting garbage

Counts

54 → 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
(fma.f64 y i #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))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) 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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i)) i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))
#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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
(fma.f64 y i #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))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x)) (.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 #s(approx (+ (* (log y) x) z) z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 1 binary64)) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (/.f64 (-.f64 (*.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64))) z))))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 #s(approx (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (*.f64 b (/.f64 (log.f64 c) a)))) #s(literal 1 binary64)) a))))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (/.f64 (-.f64 (.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64))) (log.f64 c))) (*.f64 y i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x #s(approx (+ ( (log c) (- b 1/2)) z) z)) t) a)) #s(literal 1 binary64)) a))))
#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 #s(approx (+ ( (log c) (- b 1/2)) (* (log y) x)) (*.f64 (log.f64 y) x)) 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)) #s(approx (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))))) i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
#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) #s(approx (- b 1/2) b)))))
#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 (+.f64 a t) (fma.f64 (log.f64 y) x z))))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) #s(approx (* (- b 1/2) (log c)) (.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b))) (.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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) x) (log.f64 y)) x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (*.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t)) a) #s(literal 1 binary64)) a)))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (*.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) 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)))
(+.f64 #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))) (.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ a t) (+ (+ (* (log y) x) z) (* (log c) (- b 1/2)))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) t) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) t)))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) (+.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 #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))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 #s(approx (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) (*.f64 (-.f64 (/.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)) x) (/.f64 (log.f64 y) a)) x)) #s(literal 1 binary64)) a))))
#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)) #s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (fma.f64 i (/.f64 (+.f64 (+.f64 (/.f64 a i) y) (+.f64 (/.f64 (fma.f64 (log.f64 y) x z) i) (.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i)))) t) #s(literal 1 binary64)) t)))
#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))) (* y i)) #s(approx (* (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ (* (log c) (- b 1/2)) (* (log y) x)) i))) i) (.f64 (fma.f64 i (/.f64 (fma.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) i)) #s(literal -1 binary64) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) i) (/.f64 t i)) (/.f64 a i))) y) i) y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (.f64 (+.f64 (+.f64 #s(literal 1 binary64) (neg.f64 (/.f64 (.f64 x (/.f64 (neg.f64 (log.f64 y)) i)) y))) (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) (*.f64 i y)) (/.f64 (/.f64 t i) y)) (/.f64 (/.f64 a i) y))) y)) i))

Outputs
(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))))

Calls

12 calls:

93.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))
34.0ms	a
21.0ms	(-.f64 b #s(literal 1/2 binary64))
17.0ms	i
15.0ms	y

Results

Accuracy	Segments	Branch
99.9%	1	`(log.f64 c)`
99.9%	1	`(-.f64 b #s(literal 1/2 binary64))`
99.9%	1	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
99.9%	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.9%	1	`x`
99.9%	1	`y`
99.9%	1	`z`
99.9%	1	`t`
99.9%	1	`a`
99.9%	1	`b`
99.9%	1	`c`
99.9%	1	`i`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes125.0ms (1.9%)

Memory

2.9MiB live, 195.2MiB allocated; 13ms collecting garbage

Counts

37 → 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
(fma.f64 y i #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))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) 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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i)) i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))
#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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
(fma.f64 y i #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))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x)) (.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 #s(approx (+ (* (log y) x) z) z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 1 binary64)) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (/.f64 (-.f64 (*.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64))) z))))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 #s(approx (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (*.f64 b (/.f64 (log.f64 c) a)))) #s(literal 1 binary64)) a))))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (/.f64 (-.f64 (.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64))) (log.f64 c))) (*.f64 y i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x #s(approx (+ ( (log c) (- b 1/2)) z) z)) t) a)) #s(literal 1 binary64)) a))))
#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 #s(approx (+ ( (log c) (- b 1/2)) (* (log y) x)) (*.f64 (log.f64 y) x)) 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)) #s(approx (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))))) i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
#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) #s(approx (- b 1/2) b)))))
#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

(+.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))

#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) 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 #s(approx (+ (* (log c) (- b 1/2)) (* (log y) x)) (*.f64 (log.f64 y) x)) i))) i))

Calls

12 calls:

14.0ms	z
12.0ms	i
11.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	b
10.0ms	a

Results

Accuracy	Segments	Branch
86.9%	1	`(log.f64 c)`
86.9%	1	`(-.f64 b #s(literal 1/2 binary64))`
86.9%	1	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
86.9%	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))`
93.6%	3	`x`
92.9%	2	`y`
86.9%	1	`z`
89.7%	2	`t`
88.5%	2	`a`
86.9%	1	`b`
86.9%	1	`c`
95.3%	3	`i`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes31.0ms (0.5%)

Memory

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

Counts

36 → 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
(fma.f64 y i #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))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) 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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i)) i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))
#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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
(fma.f64 y i #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))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x)) (.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 #s(approx (+ (* (log y) x) z) z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) (*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 1 binary64)) z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (/.f64 (-.f64 (*.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64))) z))))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 #s(approx (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a) (*.f64 b (/.f64 (log.f64 c) a)))) #s(literal 1 binary64)) a))))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) a) (.f64 (/.f64 (-.f64 (.f64 b b) #s(literal 1/4 binary64)) (+.f64 b #s(literal 1/2 binary64))) (log.f64 c))) (*.f64 y i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 (-.f64 (neg.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x #s(approx (+ ( (log c) (- b 1/2)) z) z)) t) a)) #s(literal 1 binary64)) a))))
#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 #s(approx (+ ( (log c) (- b 1/2)) (* (log y) x)) (*.f64 (log.f64 y) x)) 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)) #s(approx (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))))) i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) t) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
#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) #s(approx (- b 1/2) b)))))

Outputs

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

(+.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))

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

Calls

3 calls:

10.0ms	i
9.0ms	y
9.0ms	x

Results

Accuracy	Segments	Branch
93.6%	3	`x`
91.5%	2	`y`
93.4%	3	`i`

Compiler

Compiled 3 to 24 computations (-700% saved)

regimes114.0ms (1.7%)

Memory

-6.8MiB live, 136.7MiB allocated; 9ms collecting garbage

Counts

26 → 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
(fma.f64 y i #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))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) 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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i)) i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))
#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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
(fma.f64 y i #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))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x)) (.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 #s(approx (+ (* (log y) x) z) z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))
(+.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))

Outputs

(+.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))

(+.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))

Calls

12 calls:

31.0ms	a
9.0ms	(-.f64 b #s(literal 1/2 binary64))
8.0ms	x
7.0ms	t
7.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))

Results

Accuracy	Segments	Branch
68.4%	2	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
71.8%	4	`(log.f64 c)`
69.8%	3	`(-.f64 b #s(literal 1/2 binary64))`
85.8%	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))`
71.7%	4	`b`
71.8%	4	`c`
80.6%	2	`z`
81.8%	2	`a`
76.5%	2	`t`
79.9%	2	`y`
81.8%	3	`i`
78.0%	4	`x`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes62.0ms (0.9%)

Memory

-30.3MiB live, 14.9MiB allocated; 4ms collecting garbage

Counts

25 → 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
(fma.f64 y i #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))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) 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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i)) i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))
#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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
(fma.f64 y i #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))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x)) (.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 #s(approx (+ (* (log y) x) z) z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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) z) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (.f64 y i))

Outputs

(+.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))

(+.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))

Calls

1 calls:

7.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
85.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)

regimes21.0ms (0.3%)

Memory

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

Counts

24 → 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
(fma.f64 y i #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))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) 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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i)) i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))
#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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
(fma.f64 y i #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))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x)) (.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 #s(approx (+ (* (log y) x) z) z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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))

Outputs

(fma.f64 y i #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))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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))

Calls

3 calls:

7.0ms	a
7.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))
7.0ms	z

Results

Accuracy	Segments	Branch
77.0%	2	`z`
73.7%	4	`a`
82.0%	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)

regimes18.0ms (0.3%)

Memory

-14.4MiB live, 29.7MiB allocated; 7ms collecting garbage

Counts

23 → 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
(fma.f64 y i #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))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) 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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i)) i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))
#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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
(fma.f64 y i #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))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x)) (.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 #s(approx (+ (* (log y) x) z) z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))

Outputs

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

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

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

Calls

2 calls:

6.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))
6.0ms	i

Results

Accuracy	Segments	Branch
81.8%	3	`i`
76.3%	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 22 to 28 computations (-27.3% saved)

regimes7.0ms (0.1%)

Memory

16.1MiB live, 16.1MiB 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
(fma.f64 y i #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))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) 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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i)) i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))
#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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
(fma.f64 y i #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))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x)) (.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (+.f64 #s(approx (+ (* (log y) x) z) z) (*.f64 (log.f64 c) #s(approx (- b 1/2) b)))))

Outputs

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

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

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

Calls

1 calls:

6.0ms

Results

Accuracy	Segments	Branch
81.6%	3	`i`

Compiler

Compiled 1 to 8 computations (-700% saved)

regimes48.0ms (0.7%)

Memory

-13.3MiB live, 85.3MiB allocated; 12ms collecting garbage

Counts

19 → 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
(fma.f64 y i #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))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) 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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i)) i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))
#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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))

Outputs

(fma.f64 y i #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))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 c) b))))

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

Calls

7 calls:

11.0ms	i
9.0ms	t
5.0ms	z
5.0ms	a
5.0ms	x

Results

Accuracy	Segments	Branch
67.0%	3	`a`
71.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))`
66.6%	5	`x`
63.8%	4	`t`
66.6%	3	`z`
63.5%	2	`y`
70.7%	4	`i`

Compiler

Compiled 27 to 68 computations (-151.9% saved)

regimes8.0ms (0.1%)

Memory

-33.2MiB live, 13.1MiB allocated; 3ms collecting garbage

Counts

16 → 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
(fma.f64 y i #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))) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (neg (* (- (neg (/ (+ (+ (* (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) a)) 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))) z) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ y (/ a i)) (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i))) (/.f64 z i)) i))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (neg.f64 (.f64 #s(approx (- (neg (/ (+ (+ ( (log y) x) (+ (* (log c) (- b 1/2)) z)) t) a)) 1) (/.f64 (neg.f64 z) a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))
#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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (*.f64 (log.f64 y) x))))

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

Calls

1 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))

Results

Accuracy	Segments	Branch
69.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))`

Compiler

Compiled 21 to 20 computations (4.8% saved)

regimes24.0ms (0.4%)

Memory

6.8MiB live, 52.9MiB allocated; 2ms collecting garbage

Counts

6 → 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))

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)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))

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

Calls

9 calls:

4.0ms	z
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	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
2.0ms	i
2.0ms	a

Results

Accuracy	Segments	Branch
61.1%	2	`z`
50.2%	1	`a`
60.8%	3	`i`
50.2%	1	`(-.f64 b #s(literal 1/2 binary64))`
53.5%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
53.6%	3	`b`
54.3%	3	`(log.f64 c)`
54.3%	3	`c`
65.3%	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 37 to 91 computations (-145.9% saved)

regimes14.0ms (0.2%)

Memory

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

Counts

5 → 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)) 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 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) #s(approx (+ (* (log c) (- b 1/2)) z) z))))

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)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z)))

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

Calls

6 calls:

2.0ms	z
2.0ms	x
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	t
2.0ms	i

Results

Accuracy	Segments	Branch
54.5%	3	`i`
47.1%	1	`t`
47.1%	1	`z`
49.0%	2	`x`
55.6%	2	`y`
57.7%	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 26 to 60 computations (-130.8% saved)

regimes10.0ms (0.2%)

Memory

-52.6MiB live, 10.1MiB allocated; 10ms collecting garbage

Counts

3 → 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)) z)

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

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:

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))
2.0ms	y

Results

Accuracy	Segments	Branch
39.1%	2	`y`
57.5%	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)

regimes16.0ms (0.2%)

Memory

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

Counts

2 → 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)) 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

11 calls:

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	a
1.0ms	t
1.0ms	z
1.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))

Results

Accuracy	Segments	Branch
36.9%	2	`t`
41.1%	2	`z`
30.2%	3	`x`
42.1%	2	`a`
29.2%	2	`(-.f64 b #s(literal 1/2 binary64))`
27.0%	1	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
29.2%	2	`b`
27.0%	1	`(log.f64 c)`
27.0%	1	`c`
31.0%	3	`i`
47.0%	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 39 to 107 computations (-174.4% saved)

regimes12.0ms (0.2%)

Memory

-12.4MiB live, 34.6MiB allocated; 2ms collecting garbage

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 1

Calls

Call 1

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

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

Calls

9 calls:

3.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	x
1.0ms	a
1.0ms	y
1.0ms	i

Results

Accuracy	Segments	Branch
27.0%	1	`x`
27.0%	1	`(-.f64 b #s(literal 1/2 binary64))`
27.0%	1	`b`
27.0%	1	`i`
27.0%	1	`t`
27.0%	1	`y`
27.0%	1	`z`
27.0%	1	`a`
27.0%	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 31 to 86 computations (-177.4% saved)

bsearch30.0ms (0.5%)

Memory

15.7MiB live, 62.2MiB allocated; 2ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
6.0ms	1.4437640223991516e+29	2.0008305104578433e+29
20.0ms	-2.282340679165663e+58	-1.7560562948399449e+53

Samples

18.0ms

192×

valid

Compiler

Compiled 855 to 712 computations (16.7% saved)

Precisions

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

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

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

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

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

adjust: 0.0ms (0% of total)

bsearch45.0ms (0.7%)

Memory

-45.2MiB live, 50.7MiB allocated; 13ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
12.0ms	6.986233496741439e+219	6.934545852315209e+220
12.0ms	-6.323242240361859e+247	-9.721151117926734e+246

Samples

16.0ms

192×

valid

Compiler

Compiled 600 to 571 computations (4.8% saved)

Precisions

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

ival-log: 4.0ms (42.9% of total)

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

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

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

adjust: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory

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

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	235.16005359575533	1.3136511493029312e+36

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

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

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	235.16005359575533	1.3136511493029312e+36

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

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

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	235.16005359575533	1.3136511493029312e+36
0.0ms	-inf	-1.3084069713532047e+308

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch17.0ms (0.3%)

Memory

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

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
1.0ms	1.4437640223991516e+29	2.0008305104578433e+29
14.0ms	-5.504580832832693e+34	-1.3044716607292372e+33

Samples

9.0ms

112×

valid

Compiler

Compiled 1 044 to 721 computations (30.9% saved)

Precisions

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

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

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

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

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

adjust: 0.0ms (0% of total)

bsearch2.0ms (0%)

Memory

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

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
1.0ms	1.4437640223991516e+29	2.0008305104578433e+29
1.0ms	-5.504580832832693e+34	-1.3044716607292372e+33

Compiler

Compiled 1 064 to 731 computations (31.3% saved)

bsearch1.0ms (0%)

Memory

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

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	3.6270091304001613e+233	9.057193040019268e+234
0.0ms	-2.54997523213426e+55	-1.3089029484212167e+51

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

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

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	9.001863402479351	227.61764738042913

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch0.0ms (0%)

Memory

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

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	9.001863402479351	227.61764738042913
0.0ms	-inf	-1.3084069713532047e+308

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch0.0ms (0%)

Memory

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

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	1.3247818368487526e+306	2.560390437503373e+306
0.0ms	-inf	-1.3084069713532047e+308

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

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

Algorithm

3×	left-value

Steps

Time	Left	Right
0.0ms	1.3247818368487526e+306	2.560390437503373e+306
0.0ms	-81.72677530127146	9.001863402479351
0.0ms	-inf	-1.3084069713532047e+308

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch0.0ms (0%)

Memory

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

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-81.72677530127146	9.001863402479351

Compiler

Compiled 24 to 31 computations (-29.2% saved)

simplify236.0ms (3.6%)

Memory

-11.9MiB live, 33.7MiB allocated; 8ms collecting garbage

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	152	1421
1	212	1417
2	358	1417
3	933	1417
4	2252	1417
5	3920	1417
6	4201	1417
7	4415	1417
8	4708	1417
9	4877	1417
10	5287	1417
11	5914	1417
12	6257	1417
13	6334	1417
14	6358	1417
15	6417	1417
16	6469	1417
17	6525	1417
18	6568	1417
19	6589	1417
20	6616	1417
21	6641	1417
22	6736	1417
23	6748	1417

Stop Event

1×

saturated

Calls

Call 1

Inputs
(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))))
(if (<=.f64 i #s(literal -314999999999999987230774866144585829354981676969623552 binary64)) (+.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)) (if (<=.f64 i #s(literal 154999999999999994637867548672 binary64)) #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) 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 #s(approx (+ ( (log c) (- b 1/2)) (* (log y) x)) (*.f64 (log.f64 y) x)) i))) i))))
(if (<=.f64 x #s(literal -9999999999999999521471949292288813605336325386252733424243721120057734844449743607990664678980731410286045846847437914107950925140755956518597266575720169912499958425309195700665115678820350271193610461511698595727381924297989722331966923339726848 binary64)) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x))) (if (<=.f64 x #s(literal 18999999999999999179839122883132910951933034637043315656538411264726119782112681589304487795299585020986030200423294183945726332954986678944852440634741937842687297353565616163653382347195140843314202645646922719363596288 binary64)) (+.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)) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))))
(if (<=.f64 (+.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)) #s(literal 400 binary64)) (+.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)) (+.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)))
(if (<=.f64 (+.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)) #s(literal 400 binary64)) (+.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)) (+.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)))
(if (<=.f64 (+.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)) #s(literal -inf.0 binary64)) (fma.f64 y i #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x))) (if (<=.f64 (+.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)) #s(literal 400 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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))))
(if (<=.f64 i #s(literal -1499999999999999918362846480564224 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i)) (if (<=.f64 i #s(literal 154999999999999994637867548672 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))))
(if (<=.f64 i #s(literal -1499999999999999918362846480564224 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i)) (if (<=.f64 i #s(literal 154999999999999994637867548672 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))))
(if (<=.f64 (+.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)) #s(literal -20000000000000000204701340408171022992608776270649491456 binary64)) (fma.f64 y i #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) z)) (if (<=.f64 (+.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)) #s(literal 500000000000000008932922589403465161869764464983330902721886700279835046843346211837913774809974621039574077870438123630035862892627704080387855403711076771169001716823298010480011962421165907982822736097060355087078349785802142121984 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (.f64 (log.f64 c) b)))) (fma.f64 y i #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) a))))
(if (<=.f64 (+.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)) #s(literal 10 binary64)) (fma.f64 y i #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) z)) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a)))
(if (<=.f64 (+.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)) #s(literal -inf.0 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 i y)) (if (<=.f64 (+.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)) #s(literal 10 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))))
(if (<=.f64 (+.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)) #s(literal -inf.0 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 i y)) (if (<=.f64 (+.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)) #s(literal 2000000000000000034432129193472909657662175650026477964657784035784761342489150095975840903750919189137212277723396582120622098451065897041393877611422881300245257029338856920713985249936056659101378448350568693460121432177658428510879389260239589093011024831235964286525341725837632725724238309498254524416 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))))
(if (<=.f64 (+.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)) #s(literal -inf.0 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 i y)) (if (<=.f64 (+.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)) #s(literal -50 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z) (if (<=.f64 (+.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)) #s(literal 2000000000000000034432129193472909657662175650026477964657784035784761342489150095975840903750919189137212277723396582120622098451065897041393877611422881300245257029338856920713985249936056659101378448350568693460121432177658428510879389260239589093011024831235964286525341725837632725724238309498254524416 binary64)) #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)))))
(if (<=.f64 (+.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)) #s(literal -50 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)) a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Outputs
(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))))
(if (<=.f64 i #s(literal -314999999999999987230774866144585829354981676969623552 binary64)) (+.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)) (if (<=.f64 i #s(literal 154999999999999994637867548672 binary64)) #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) 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 #s(approx (+ ( (log c) (- b 1/2)) (* (log y) x)) (*.f64 (log.f64 y) x)) i))) i))))
(if (<=.f64 x #s(literal -9999999999999999521471949292288813605336325386252733424243721120057734844449743607990664678980731410286045846847437914107950925140755956518597266575720169912499958425309195700665115678820350271193610461511698595727381924297989722331966923339726848 binary64)) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x))) (if (<=.f64 x #s(literal 18999999999999999179839122883132910951933034637043315656538411264726119782112681589304487795299585020986030200423294183945726332954986678944852440634741937842687297353565616163653382347195140843314202645646922719363596288 binary64)) (+.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)) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))))
(if (or (<=.f64 x #s(literal -9999999999999999521471949292288813605336325386252733424243721120057734844449743607990664678980731410286045846847437914107950925140755956518597266575720169912499958425309195700665115678820350271193610461511698595727381924297989722331966923339726848 binary64)) (not (<=.f64 x #s(literal 18999999999999999179839122883132910951933034637043315656538411264726119782112681589304487795299585020986030200423294183945726332954986678944852440634741937842687297353565616163653382347195140843314202645646922719363596288 binary64)))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x))) (+.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)))
(if (<=.f64 (+.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)) #s(literal 400 binary64)) (+.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)) (+.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)))
(if (<=.f64 (+.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)) #s(literal 400 binary64)) (+.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)) (+.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)))
(if (<=.f64 (+.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)) #s(literal -inf.0 binary64)) (fma.f64 y i #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x))) (if (<=.f64 (+.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)) #s(literal 400 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) 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))))
(if (<=.f64 i #s(literal -1499999999999999918362846480564224 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i)) (if (<=.f64 i #s(literal 154999999999999994637867548672 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))))
(if (or (<=.f64 i #s(literal -1499999999999999918362846480564224 binary64)) (not (<=.f64 i #s(literal 154999999999999994637867548672 binary64)))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))))
(if (<=.f64 i #s(literal -1499999999999999918362846480564224 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i)) (if (<=.f64 i #s(literal 154999999999999994637867548672 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i))))
(if (or (<=.f64 i #s(literal -1499999999999999918362846480564224 binary64)) (not (<=.f64 i #s(literal 154999999999999994637867548672 binary64)))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 y (/.f64 a i)) #s(approx (+ (+ (/ t i) (/ z i)) (/ (+ ( (log c) (- b 1/2)) (* (log y) x)) i)) (/.f64 z i))) i)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ a t) a) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)))))
(if (<=.f64 (+.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)) #s(literal -20000000000000000204701340408171022992608776270649491456 binary64)) (fma.f64 y i #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) z)) (if (<=.f64 (+.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)) #s(literal 500000000000000008932922589403465161869764464983330902721886700279835046843346211837913774809974621039574077870438123630035862892627704080387855403711076771169001716823298010480011962421165907982822736097060355087078349785802142121984 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) (.f64 (log.f64 c) b)))) (fma.f64 y i #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) a))))
(if (<=.f64 (+.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)) #s(literal 10 binary64)) (fma.f64 y i #s(approx (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) z)) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a)))
(if (<=.f64 (+.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)) #s(literal -inf.0 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 i y)) (if (<=.f64 (+.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)) #s(literal 10 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a))))
(if (<=.f64 (+.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)) #s(literal -inf.0 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 i y)) (if (<=.f64 (+.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)) #s(literal 2000000000000000034432129193472909657662175650026477964657784035784761342489150095975840903750919189137212277723396582120622098451065897041393877611422881300245257029338856920713985249936056659101378448350568693460121432177658428510879389260239589093011024831235964286525341725837632725724238309498254524416 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))))
(if (or (<=.f64 (+.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)) #s(literal -inf.0 binary64)) (not (<=.f64 (+.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)) #s(literal 2000000000000000034432129193472909657662175650026477964657784035784761342489150095975840903750919189137212277723396582120622098451065897041393877611422881300245257029338856920713985249936056659101378448350568693460121432177658428510879389260239589093011024831235964286525341725837632725724238309498254524416 binary64)))) #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 a t) #s(approx (+ (+ (* (log y) x) z) (* (log c) (- b 1/2))) z))))
(if (<=.f64 (+.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)) #s(literal -inf.0 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 i y)) (if (<=.f64 (+.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)) #s(literal -50 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z) (if (<=.f64 (+.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)) #s(literal 2000000000000000034432129193472909657662175650026477964657784035784761342489150095975840903750919189137212277723396582120622098451065897041393877611422881300245257029338856920713985249936056659101378448350568693460121432177658428510879389260239589093011024831235964286525341725837632725724238309498254524416 binary64)) #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)))))
(if (<=.f64 (+.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)) #s(literal -50 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)) a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

derivations598.0ms (9%)

Memory

22.0MiB live, 493.1MiB allocated; 51ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 1 425 to 155 computations (89.1% saved)

preprocess151.0ms (2.3%)

Memory: 1.2MiB live, 183.1MiB allocated; 37ms collecting garbage
Compiler: Compiled 2 928 to 384 computations (86.9% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze13.0ms (0.2%)

sample1.6s (24.7%)

explain254.0ms (3.8%)

preprocess146.0ms (2.2%)

eval0.0ms (0%)

prune1.0ms (0%)

series271.0ms (4.1%)

rewrite385.0ms (5.8%)

eval23.0ms (0.3%)

prune23.0ms (0.3%)

series177.0ms (2.7%)

rewrite287.0ms (4.3%)

eval51.0ms (0.8%)

prune21.0ms (0.3%)

series278.0ms (4.2%)

rewrite237.0ms (3.6%)

eval82.0ms (1.2%)

prune29.0ms (0.4%)

series466.0ms (7%)

rewrite250.0ms (3.8%)

eval71.0ms (1.1%)

prune49.0ms (0.7%)

regimes279.0ms (4.2%)

regimes125.0ms (1.9%)

regimes31.0ms (0.5%)

regimes114.0ms (1.7%)

regimes62.0ms (0.9%)

regimes21.0ms (0.3%)

regimes18.0ms (0.3%)

regimes7.0ms (0.1%)

regimes48.0ms (0.7%)

regimes8.0ms (0.1%)

regimes24.0ms (0.4%)

regimes14.0ms (0.2%)

regimes10.0ms (0.2%)

regimes16.0ms (0.2%)

regimes12.0ms (0.2%)

bsearch30.0ms (0.5%)

bsearch45.0ms (0.7%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch17.0ms (0.3%)

bsearch2.0ms (0%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch0.0ms (0%)

bsearch0.0ms (0%)

bsearch1.0ms (0%)

bsearch0.0ms (0%)

simplify236.0ms (3.6%)

derivations598.0ms (9%)

preprocess151.0ms (2.3%)

end0.0ms (0%)

Profiling