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

analyze25.0ms (0.2%)

Memory

-15.3MiB live, 27.5MiB allocated; 12ms 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)

sample2.9s (26.6%)

Memory

-96.0MiB live, 2 959.5MiB allocated; 1.9s collecting garbage

Samples

2.4s	8 253×	0	valid
0.0ms	2×	1	valid
0.0ms	1×	2	valid

Precisions

Click to see histograms. Total time spent on operations: 1.9s

ival-log: 1.0s (54.6% of total)

ival-add: 536.0ms (28.4% of total)

ival-mult: 233.0ms (12.3% of total)

ival-sub: 70.0ms (3.7% of total)

ival-true: 6.0ms (0.3% of total)

exact: 5.0ms (0.3% of total)

adjust: 3.0ms (0.2% of total)

ival-assert: 3.0ms (0.2% of total)

Bogosity

explain429.0ms (3.9%)

Memory

-43.2MiB live, 469.4MiB allocated; 92ms 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

84.0ms

512×

valid

Compiler

Compiled 207 to 64 computations (69.1% saved)

Precisions

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

ival-mult: 16.0ms (39.9% of total)

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

ival-add: 10.0ms (24.9% of total)

ival-sub: 3.0ms (7.5% of total)

ival-true: 0.0ms (0% of total)

adjust: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

preprocess143.0ms (1.3%)

Memory

8.7MiB live, 105.9MiB allocated; 10ms 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.1MiB live, 0.1MiB allocated; 0ms collecting garbage
Compiler: Compiled 0 to 8 computations (-∞% saved)

prune0.0ms (0%)

Memory

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

Alt Table

Click to see full alt table

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

Compiler

Compiled 21 to 20 computations (4.8% saved)

simplify86.0ms (0.8%)

Memory

1.8MiB live, 48.4MiB allocated; 3ms collecting garbage

Localize:

Found 4 expressions of interest:

New	Metric	Score
cost-diff	0	(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)
cost-diff	1	(+.f64 (*.f64 x (log.f64 y)) z)
cost-diff	1	(+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
cost-diff	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))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	20	91
0	31	91
1	53	91
2	148	91
3	598	91
4	1903	91
5	3203	91
6	3289	91
7	3295	91
8	3295	91
9	3947	91
10	3977	91
11	3977	91
0	3977	83

Stop Event

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

localize61.0ms (0.5%)

Memory

7.2MiB live, 51.0MiB allocated; 7ms collecting garbage

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0.01171875	(+.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))
accuracy	0.01171875	(+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.15234375	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	0.21484375	(*.f64 x (log.f64 y))

Samples

34.0ms

256×

valid

Compiler

Compiled 93 to 22 computations (76.3% saved)

Precisions

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

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

ival-add: 5.0ms (29.9% of total)

ival-mult: 5.0ms (29.9% of total)

ival-sub: 1.0ms (6% of total)

ival-true: 0.0ms (0% of total)

adjust: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

series293.0ms (2.6%)

Memory

17.4MiB live, 482.8MiB allocated; 114ms collecting garbage

Counts

6 → 95

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

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

simplify182.0ms (1.6%)

Memory

-18.6MiB live, 256.6MiB allocated; 25ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	442	2874
1	1296	2802
2	4882	2794
0	8381	2497

Stop Event

1×	iter limit
1×	node limit

Counts

95 → 95

Calls

Call 1

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

rewrite233.0ms (2.1%)

Memory

33.5MiB live, 404.7MiB allocated; 91ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	20	64
0	31	64
1	132	64
2	1219	64
0	8073	57

Stop Event

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

Counts

6 → 367

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

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

eval133.0ms (1.2%)

Memory: -11.2MiB live, 184.2MiB allocated; 64ms collecting garbage
Compiler: Compiled 26 042 to 2 147 computations (91.8% saved)

prune37.0ms (0.3%)

Memory

8.7MiB live, 56.2MiB allocated; 1ms collecting garbage

Pruning

21 alts after pruning (21 fresh and 0 done)

	Pruned	Kept	Total
New	436	21	457
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	437	21	458

Accuracy

99.9%

Counts

458 → 21

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 a (+.f64 t (fma.f64 (log.f64 y) x z)))))
	90.9%	(+.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* x (log y)) z) (.f64 (neg.f64 z) (fma.f64 (/.f64 (log.f64 y) z) (neg.f64 x) #s(literal -1 binary64)))) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
▶	60.7%	(+.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))
	62.7%	(+.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))
	72.5%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x z)) t) a) b) (log.f64 c)) b)) (.f64 y i))
	37.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 y) x)) (.f64 y i))
	38.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (log.f64 c) b)) (.f64 y i))
	42.9%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) z) (*.f64 y i))
	45.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
	66.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))) a) t) t t))
▶	77.2%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x t))) a) z) z z))
	79.0%	#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)) (fma.f64 (log.f64 y) x (+.f64 (+.f64 t z) a))))
	99.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))) a))
	84.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z))))
	71.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z))) x) (log.f64 y)) x))
	65.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (+.f64 (/.f64 (+.f64 a t) y) (/.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) y)) i) y))
	16.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
▶	18.2%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
	22.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
	22.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z)
▶	24.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 1 290 to 1 058 computations (18% saved)

simplify132.0ms (1.2%)

Memory

5.8MiB live, 192.7MiB allocated; 16ms collecting garbage

Localize:

Found 16 expressions of interest:

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

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	43	346
0	65	331
1	140	331
2	377	330
3	1453	328
4	4536	328
0	8728	325

Stop Event

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

Calls

Call 1

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

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

localize126.0ms (1.1%)

Memory

-27.7MiB live, 215.8MiB allocated; 22ms collecting garbage

Localize:

Found 16 expressions of interest:

New	Metric	Score
accuracy	0.09375	(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x t))
accuracy	0.1484375	(fma.f64 (log.f64 y) x t)
accuracy	2.912306567636183	(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x t))) a) z)
accuracy	14.599572312373258	(fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x t))) a) z) z z)
accuracy	0.01171875	(+.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))
accuracy	0.01171875	(+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
accuracy	0.15234375	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy	42.920199844595984	#s(approx (+ (+ (+ (* x (log y)) z) t) a) z)
accuracy	0.0	(log.f64 c)
accuracy	0.28125	(*.f64 (log.f64 c) b)
accuracy	52.32717427322436	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
accuracy	48.20051785100899	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)
accuracy	0.0	(log.f64 c)
accuracy	0.00390625	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 a (+.f64 t (fma.f64 (log.f64 y) x z)))))
accuracy	0.07421875	(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 a (+.f64 t (fma.f64 (log.f64 y) x z))))
accuracy	0.10546875	(fma.f64 (log.f64 y) x z)

Samples

68.0ms

256×

valid

Compiler

Compiled 337 to 38 computations (88.7% saved)

Precisions

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

ival-add: 16.0ms (39.6% of total)

ival-mult: 15.0ms (37.1% of total)

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

ival-div: 2.0ms (4.9% of total)

ival-sub: 1.0ms (2.5% of total)

adjust: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

series384.0ms (3.5%)

Memory

13.9MiB live, 528.6MiB allocated; 96ms collecting garbage

Counts

18 → 269

Calls

Call 1

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

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

Calls

24 calls:

Time	Variable		Point	Expression
68.0ms	z	@	inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (- b 1/2) (+ (+ (+ (+ (+ (* 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)) (* (log c) b) (+ (+ (+ (+ (+ (* 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)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (* (log y) x) z) (+ (* (log y) x) t) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)))
41.0ms	b	@	0	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (- b 1/2) (+ (+ (+ (+ (+ (* 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)) (* (log c) b) (+ (+ (+ (+ (+ (* 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)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (* (log y) x) z) (+ (* (log y) x) t) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)))
26.0ms	i	@	0	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (- b 1/2) (+ (+ (+ (+ (+ (* 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)) (* (log c) b) (+ (+ (+ (+ (+ (* 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)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (* (log y) x) z) (+ (* (log y) x) t) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)))
24.0ms	y	@	0	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (- b 1/2) (+ (+ (+ (+ (+ (* 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)) (* (log c) b) (+ (+ (+ (+ (+ (* 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)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (* (log y) x) z) (+ (* (log y) x) t) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)))
23.0ms	a	@	-inf	((+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (- b 1/2) (+ (+ (+ (+ (+ (* 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)) (* (log c) b) (+ (+ (+ (+ (+ (* 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)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (* (log y) x) z) (+ (* (log y) x) t) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)))

simplify184.0ms (1.7%)

Memory

35.5MiB live, 214.7MiB allocated; 39ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	879	9418
1	2516	9120
0	8510	8059

Stop Event

1×	iter limit
1×	node limit

Counts

269 → 269

Calls

Call 1

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

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

rewrite237.0ms (2.1%)

Memory

-10.3MiB live, 193.5MiB allocated; 24ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	43	270
0	65	258
1	382	258
2	3246	258
0	8566	255

Stop Event

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

Counts

18 → 331

Calls

Call 1

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

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

eval134.0ms (1.2%)

Memory: -38.2MiB live, 128.2MiB allocated; 77ms collecting garbage
Compiler: Compiled 26 218 to 2 501 computations (90.5% saved)

prune48.0ms (0.4%)

Memory

27.6MiB live, 74.1MiB allocated; 2ms collecting garbage

Pruning

27 alts after pruning (25 fresh and 2 done)

	Pruned	Kept	Total
New	541	18	559
Fresh	9	7	16
Picked	3	2	5
Done	0	0	0
Total	553	27	580

Accuracy

99.9%

Counts

580 → 27

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	60.7%	(fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z)))
▶	90.9%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 a (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z))))))
	82.6%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) t) a) a a)))
▶	70.9%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) (log.f64 y)) x)))
	37.3%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (*.f64 (log.f64 y) x)))
	38.3%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (*.f64 (log.f64 c) b)))
	42.9%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) z))
	45.4%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) a))
	62.7%	(+.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))
	72.5%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x z)) t) a) b) (log.f64 c)) b)) (.f64 y i))
	45.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
	65.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) (*.f64 (log.f64 y) x))) a) z) z z))
	54.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) z) z z))
	56.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (*.f64 (+.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (/.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) a) y)) i) y)) z) z z))
	34.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (*.f64 (log.f64 y) x)) z) z z))
	40.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (*.f64 i y)) z) z z))
▶	22.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) t) z) z z))
	35.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) a) z) z z))
	79.0%	#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)) (fma.f64 (log.f64 y) x (+.f64 (+.f64 t z) a))))
	64.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (.f64 (neg.f64 b) (-.f64 (/.f64 (neg.f64 (log.f64 c)) z) (/.f64 (+.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) a) z) (/.f64 (+.f64 (fma.f64 (log.f64 y) x (.f64 i y)) t) z)) b)))) z z))
	33.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (*.f64 b (/.f64 (log.f64 c) z))) z z))
	65.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (+.f64 (/.f64 (+.f64 a t) y) (/.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)) y)) i) y))
	16.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
✓	18.2%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
	22.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
▶	22.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) z))
✓	24.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 2 021 to 1 468 computations (27.4% saved)

simplify168.0ms (1.5%)

Memory

-14.3MiB live, 128.1MiB allocated; 23ms collecting garbage

Localize:

Found 18 expressions of interest:

New	Metric	Score
cost-diff	0	(+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) (log.f64 y))
cost-diff	0	(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) (log.f64 y)) x)
cost-diff	0	#s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) (log.f64 y)) x))
cost-diff	0	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) (log.f64 y)) x)))
cost-diff	0	(log.f64 c)
cost-diff	0	(-.f64 b #s(literal 1/2 binary64))
cost-diff	0	(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z))
cost-diff	0	(fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z)))
cost-diff	0	#s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) t)
cost-diff	0	(/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) t) z)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) t) z) z z))
cost-diff	3	(fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) t) z) z z)
cost-diff	0	#s(approx (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) z)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) z))
cost-diff	0	(log.f64 c)
cost-diff	0	(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 a (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)))))
cost-diff	0	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 a (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z))))))
cost-diff	2	(*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	63	570
0	90	570
1	189	570
2	519	560
3	1928	544
4	6737	544
0	8895	508

Stop Event

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

Calls

Call 1

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

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

localize132.0ms (1.2%)

Memory

15.5MiB live, 257.0MiB allocated; 28ms collecting garbage

Localize:

Found 18 expressions of interest:

New	Metric	Score
accuracy	0.00390625	(+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a)
accuracy	0.11328125	(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z)
accuracy	0.32240825834847164	(/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x)
accuracy	19.203949820189735	(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) x) (log.f64 y)) x)
accuracy	0.0	(log.f64 c)
accuracy	0.00390625	(fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z)))
accuracy	0.07421875	(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z))
accuracy	42.920199844595984	#s(approx (+ (+ (+ (* x (log y)) z) t) a) z)
accuracy	0.0	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) t) z) z z))
accuracy	2.912306567636183	(/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) t) z)
accuracy	14.599572312373258	(fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) t) z) z z)
accuracy	58.87766840034017	#s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) t)
accuracy	0.0	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) z))
accuracy	49.57402814756688	#s(approx (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) z)
accuracy	0.07421875	(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 a (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)))))
accuracy	0.09765625	(fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64))
accuracy	0.29296875	(/.f64 (log.f64 y) z)
accuracy	5.929687475182125	(*.f64 (fma.f64 x (/.f64 (log.f64 y) z) #s(literal 1 binary64)) z)

Samples

100.0ms

256×

valid

Compiler

Compiled 431 to 50 computations (88.4% saved)

Precisions

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

ival-add: 25.0ms (45.2% of total)

ival-mult: 15.0ms (27.1% of total)

ival-log: 9.0ms (16.3% of total)

ival-div: 5.0ms (9% of total)

ival-sub: 1.0ms (1.8% of total)

adjust: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

series333.0ms (3%)

Memory

-10.9MiB live, 473.1MiB allocated; 68ms collecting garbage

Counts

23 → 379

Calls

Call 1

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

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

Calls

24 calls:

Time	Variable		Point	Expression
48.0ms	x	@	0	((* (+ (* x (/ (log y) z)) 1) z) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (* y i) (+ (* (- 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) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (* (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) x) (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) (/ (log y) z) (+ (* x (/ (log y) z)) 1) (+ (+ (+ (* x (log y)) z) t) a) (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (+ (* (log c) (- b 1/2)) z) (+ (+ (+ (* (log c) (- b 1/2)) z) t) a))
34.0ms	y	@	inf	((* (+ (* x (/ (log y) z)) 1) z) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (* y i) (+ (* (- 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) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (* (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) x) (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) (/ (log y) z) (+ (* x (/ (log y) z)) 1) (+ (+ (+ (* x (log y)) z) t) a) (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (+ (* (log c) (- b 1/2)) z) (+ (+ (+ (* (log c) (- b 1/2)) z) t) a))
28.0ms	z	@	inf	((* (+ (* x (/ (log y) z)) 1) z) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (* y i) (+ (* (- 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) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (* (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) x) (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) (/ (log y) z) (+ (* x (/ (log y) z)) 1) (+ (+ (+ (* x (log y)) z) t) a) (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (+ (* (log c) (- b 1/2)) z) (+ (+ (+ (* (log c) (- b 1/2)) z) t) a))
21.0ms	z	@	-inf	((* (+ (* x (/ (log y) z)) 1) z) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (* y i) (+ (* (- 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) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (* (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) x) (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) (/ (log y) z) (+ (* x (/ (log y) z)) 1) (+ (+ (+ (* x (log y)) z) t) a) (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (+ (* (log c) (- b 1/2)) z) (+ (+ (+ (* (log c) (- b 1/2)) z) t) a))
20.0ms	c	@	inf	((* (+ (* x (/ (log y) z)) 1) z) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (* y i) (+ (* (- 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) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (* (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) x) (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) (/ (log y) z) (+ (* x (/ (log y) z)) 1) (+ (+ (+ (* x (log y)) z) t) a) (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (+ (* (log c) (- b 1/2)) z) (+ (+ (+ (* (log c) (- b 1/2)) z) t) a))

simplify215.0ms (1.9%)

Memory

-7.2MiB live, 217.8MiB allocated; 38ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1200	13537
1	3343	13109
0	9293	11752

Stop Event

1×	iter limit
1×	node limit

Counts

379 → 379

Calls

Call 1

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

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

rewrite241.0ms (2.2%)

Memory

17.8MiB live, 252.1MiB allocated; 30ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	63	465
0	90	465
1	536	459
2	4840	459
0	9422	430

Stop Event

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

Counts

23 → 255

Calls

Call 1

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

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

eval88.0ms (0.8%)

Memory: -5.5MiB live, 142.0MiB allocated; 29ms collecting garbage
Compiler: Compiled 27 714 to 2 783 computations (90% saved)

prune62.0ms (0.6%)

Memory

-11.1MiB live, 92.2MiB allocated; 11ms collecting garbage

Pruning

36 alts after pruning (32 fresh and 4 done)

	Pruned	Kept	Total
New	525	22	547
Fresh	10	10	20
Picked	3	2	5
Done	0	2	2
Total	538	36	574

Accuracy

100.0%

Counts

574 → 36

Alt Table

Click to see full alt table

Status	Accuracy	Program
	54.9%	(fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (log.f64 y) x))))
	62.7%	(fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a)))
▶	91.0%	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 a (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (log.f64 y) (/.f64 x z) #s(literal 1 binary64)) z))))))
	58.9%	(fma.f64 y i (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z)))
	44.8%	(fma.f64 y i (fma.f64 #s(approx (- b 1/2) #s(literal -1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z)))
	64.0%	(fma.f64 y i #s(approx (+ (* (- b 1/2) (log c)) (+ (+ (+ (* x (log y)) z) t) a)) (fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) a)) t) t t)))
	37.3%	(fma.f64 y i #s(approx (+ (* (- b 1/2) (log c)) (+ (+ (+ (* x (log y)) z) t) a)) (*.f64 (log.f64 y) x)))
	38.3%	(fma.f64 y i #s(approx (+ (* (- b 1/2) (log c)) (+ (+ (+ (* x (log y)) z) t) a)) (*.f64 (log.f64 c) b)))
	42.9%	(fma.f64 y i #s(approx (+ (* (- b 1/2) (log c)) (+ (+ (+ (* x (log y)) z) t) a)) z))
	45.4%	(fma.f64 y i #s(approx (+ (* (- b 1/2) (log c)) (+ (+ (+ (* x (log y)) z) t) a)) a))
	37.7%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (/.f64 (*.f64 (-.f64 (pow.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64))) x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x) (log.f64 y)))))
	58.5%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 (+.f64 (+.f64 #s(approx (+ ( (log c) (- b 1/2)) z) z) t) a) x) (log.f64 y)) x)))
	46.1%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 #s(approx (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) a) x) (log.f64 y)) x)))
	60.8%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 #s(approx (/ (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) x) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 t z)) (.f64 a x)) (/.f64 #s(literal 1 binary64) x)) a)) (log.f64 y)) x)))
	55.0%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 #s(approx (+ (/ (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) x) (log y)) (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 (+.f64 t z) a)) x)) x)))
	32.5%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 #s(approx (+ (/ (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) x) (log y)) (/.f64 z x)) x)))
	31.2%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 #s(approx (+ (/ (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) x) (log y)) (/.f64 a x)) x)))
	31.6%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 #s(approx (+ (/ (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) x) (log y)) (*.f64 b (/.f64 (log.f64 c) x))) x)))
	64.3%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) #s(approx (* (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) x) (*.f64 (fma.f64 x (/.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 t z)) x) (log.f64 y)) a) #s(literal 1 binary64)) a))))
	72.5%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x z)) t) a) b) (log.f64 c)) b)) (.f64 y i))
	45.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
▶	54.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) z) z z))
	40.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (*.f64 i y)) z) z z))
✓	22.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) t) z) z z))
	35.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) a) z) z z))
	79.0%	#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)) (fma.f64 (log.f64 y) x (+.f64 (+.f64 t z) a))))
▶	34.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (*.f64 (/.f64 (log.f64 y) z) x)) z z))
	57.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x a) (.f64 z y)) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (*.f64 z y)) (/.f64 i z))) y)) z z))
	64.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (.f64 (neg.f64 b) (-.f64 (/.f64 (neg.f64 (log.f64 c)) z) (/.f64 (+.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) a) z) (/.f64 (+.f64 (fma.f64 (log.f64 y) x (.f64 i y)) t) z)) b)))) z z))
	33.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (*.f64 b (/.f64 (log.f64 c) z))) z z))
▶	64.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x a) y) (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 t z)) y)) i) y))
	16.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
✓	18.2%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
▶	22.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
✓	22.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) z))
✓	24.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 2 762 to 1 943 computations (29.7% saved)

simplify128.0ms (1.2%)

Memory

13.3MiB live, 148.2MiB allocated; 7ms collecting garbage

Localize:

Found 18 expressions of interest:

New	Metric	Score
cost-diff	0	(+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x a) y) (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 t z)) y)) i)
cost-diff	0	(*.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x a) y) (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 t z)) y)) i) y)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x a) y) (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 t z)) y)) i) y))
cost-diff	2	(+.f64 (/.f64 (fma.f64 (log.f64 y) x a) y) (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 t z)) y))
cost-diff	0	(*.f64 (/.f64 (log.f64 y) z) x)
cost-diff	0	#s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (*.f64 (/.f64 (log.f64 y) z) x))
cost-diff	0	(fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (*.f64 (/.f64 (log.f64 y) z) x)) z z)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (*.f64 (/.f64 (log.f64 y) z) x)) z z))
cost-diff	0	(+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a)
cost-diff	0	(/.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) z)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) z) z z))
cost-diff	3	(fma.f64 (/.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) z) z z)
cost-diff	0	(*.f64 i y)
cost-diff	0	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
cost-diff	0	(log.f64 c)
cost-diff	0	(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 a (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (log.f64 y) (/.f64 x z) #s(literal 1 binary64)) z)))))
cost-diff	0	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 a (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (log.f64 y) (/.f64 x z) #s(literal 1 binary64)) z))))))
cost-diff	2	(*.f64 (fma.f64 (log.f64 y) (/.f64 x z) #s(literal 1 binary64)) z)

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	65	613
0	100	605
1	203	601
2	563	596
3	2085	582
4	6902	582
0	8160	549

Stop Event

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

Calls

Call 1

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

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

localize175.0ms (1.6%)

Memory

6.0MiB live, 248.1MiB allocated; 23ms collecting garbage

Localize:

Found 18 expressions of interest:

New	Metric	Score
accuracy	0.32764085284224986	(/.f64 (fma.f64 (log.f64 y) x a) y)
accuracy	0.3430392158483264	(/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 t z)) y)
accuracy	4.656223165792676	(+.f64 (/.f64 (fma.f64 (log.f64 y) x a) y) (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 t z)) y))
accuracy	22.063380427004354	(*.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x a) y) (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 t z)) y)) i) y)
accuracy	0.19921875	(*.f64 (/.f64 (log.f64 y) z) x)
accuracy	0.29296875	(/.f64 (log.f64 y) z)
accuracy	14.599572312373258	(fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (*.f64 (/.f64 (log.f64 y) z) x)) z z)
accuracy	48.3263591828511	#s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (*.f64 (/.f64 (log.f64 y) z) x))
accuracy	0.00390625	(+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a)
accuracy	2.912306567636183	(/.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) z)
accuracy	14.599572312373258	(fma.f64 (/.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) z) z z)
accuracy	51.39079098892765	#s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)
accuracy	0.0	(*.f64 i y)
accuracy	49.682610113736665	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
accuracy	0.00390625	(fma.f64 y i (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 a (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (log.f64 y) (/.f64 x z) #s(literal 1 binary64)) z))))))
accuracy	0.07421875	(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 a (+.f64 t #s(approx (+ (* (log y) x) z) (*.f64 (fma.f64 (log.f64 y) (/.f64 x z) #s(literal 1 binary64)) z)))))
accuracy	0.12109375	(fma.f64 (log.f64 y) (/.f64 x z) #s(literal 1 binary64))
accuracy	5.929687475182125	(*.f64 (fma.f64 (log.f64 y) (/.f64 x z) #s(literal 1 binary64)) z)

Samples

112.0ms

256×

valid

Compiler

Compiled 476 to 55 computations (88.4% saved)

Precisions

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

ival-mult: 30.0ms (44% of total)

ival-add: 21.0ms (30.8% of total)

ival-div: 8.0ms (11.7% of total)

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

ival-sub: 3.0ms (4.4% of total)

adjust: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

ival-true: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

series362.0ms (3.3%)

Memory

23.3MiB live, 685.0MiB allocated; 78ms collecting garbage

Counts

23 → 337

Calls

Call 1

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

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

Calls

24 calls:

Time	Variable		Point	Expression
36.0ms	c	@	inf	((* (+ (* (log y) (/ x z)) 1) z) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* i y) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (* (/ (log y) z) x) (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (+ (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) y) (+ (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) (+ (* (log y) (/ x z)) 1) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) (/ (log y) z) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y) (/ (+ (* (log y) x) a) y))
34.0ms	y	@	inf	((* (+ (* (log y) (/ x z)) 1) z) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* i y) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (* (/ (log y) z) x) (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (+ (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) y) (+ (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) (+ (* (log y) (/ x z)) 1) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) (/ (log y) z) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y) (/ (+ (* (log y) x) a) y))
30.0ms	z	@	-inf	((* (+ (* (log y) (/ x z)) 1) z) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* i y) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (* (/ (log y) z) x) (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (+ (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) y) (+ (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) (+ (* (log y) (/ x z)) 1) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) (/ (log y) z) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y) (/ (+ (* (log y) x) a) y))
27.0ms	y	@	-inf	((* (+ (* (log y) (/ x z)) 1) z) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* i y) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (* (/ (log y) z) x) (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (+ (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) y) (+ (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) (+ (* (log y) (/ x z)) 1) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) (/ (log y) z) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y) (/ (+ (* (log y) x) a) y))
23.0ms	z	@	inf	((* (+ (* (log y) (/ x z)) 1) z) (+ (* y i) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z))))) (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (log c) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* i y) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (* (/ (log y) z) x) (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (* (+ (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) y) (+ (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) (+ (* (log y) (/ x z)) 1) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) (/ (log y) z) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y) (/ (+ (* (log y) x) a) y))

simplify208.0ms (1.9%)

Memory

-47.1MiB live, 247.6MiB allocated; 57ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1206	13177
1	3544	12660
0	8832	11479

Stop Event

1×	iter limit
1×	node limit

Counts

337 → 337

Calls

Call 1

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

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

rewrite175.0ms (1.6%)

Memory

10.8MiB live, 203.7MiB allocated; 11ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	65	478
0	100	470
1	526	458
0	4825	437

Stop Event

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

Counts

23 → 286

Calls

Call 1

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

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

eval106.0ms (1%)

Memory: 25.2MiB live, 163.1MiB allocated; 11ms collecting garbage
Compiler: Compiled 33 535 to 2 973 computations (91.1% saved)

prune62.0ms (0.6%)

Memory

3.2MiB live, 145.1MiB allocated; 13ms collecting garbage

Pruning

44 alts after pruning (39 fresh and 5 done)

	Pruned	Kept	Total
New	567	14	581
Fresh	2	25	27
Picked	4	1	5
Done	0	4	4
Total	573	44	617

Accuracy

100.0%

Counts

617 → 44

Alt Table

Click to see full alt table

Status	Accuracy	Program
	54.9%	(fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) (*.f64 (log.f64 y) x))))
	62.7%	(fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a)))
	58.9%	(fma.f64 y i (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z)))
	44.8%	(fma.f64 y i (fma.f64 #s(approx (- b 1/2) #s(literal -1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z)))
	64.0%	(fma.f64 y i #s(approx (+ (* (- b 1/2) (log c)) (+ (+ (+ (* x (log y)) z) t) a)) (fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) a)) t) t t)))
	37.3%	(fma.f64 y i #s(approx (+ (* (- b 1/2) (log c)) (+ (+ (+ (* x (log y)) z) t) a)) (*.f64 (log.f64 y) x)))
	38.3%	(fma.f64 y i #s(approx (+ (* (- b 1/2) (log c)) (+ (+ (+ (* x (log y)) z) t) a)) (*.f64 (log.f64 c) b)))
	42.9%	(fma.f64 y i #s(approx (+ (* (- b 1/2) (log c)) (+ (+ (+ (* x (log y)) z) t) a)) z))
	45.4%	(fma.f64 y i #s(approx (+ (* (- b 1/2) (log c)) (+ (+ (+ (* x (log y)) z) t) a)) a))
	37.7%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (/.f64 (*.f64 (-.f64 (pow.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64))) x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x) (log.f64 y)))))
	58.5%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 (+.f64 (+.f64 #s(approx (+ ( (log c) (- b 1/2)) z) z) t) a) x) (log.f64 y)) x)))
	46.1%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 #s(approx (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) a) x) (log.f64 y)) x)))
	55.0%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 #s(approx (+ (/ (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) x) (log y)) (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 (+.f64 t z) a)) x)) x)))
	32.5%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 #s(approx (+ (/ (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) x) (log y)) (/.f64 z x)) x)))
	31.2%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 #s(approx (+ (/ (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) x) (log y)) (/.f64 a x)) x)))
	31.6%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 #s(approx (+ (/ (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) x) (log y)) (*.f64 b (/.f64 (log.f64 c) x))) x)))
	64.3%	(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) #s(approx (* (+ (/ (+ (+ (+ (* (log c) (- b 1/2)) z) t) a) x) (log y)) x) (*.f64 (fma.f64 x (/.f64 (+.f64 (/.f64 (fma.f64 (log.f64 c) (+.f64 #s(literal -1/2 binary64) b) (+.f64 t z)) x) (log.f64 y)) a) #s(literal 1 binary64)) a))))
	45.3%	(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) a) (*.f64 y i))
	30.6%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (fma.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) z (.f64 z a)) (.f64 z z)) z z))
	40.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) (*.f64 i y)) z) z z))
✓	22.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) t) z) z z))
	35.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) a) z) z z))
	66.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) z))
	79.0%	#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)) (fma.f64 (log.f64 y) x (+.f64 (+.f64 t z) a))))
	34.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (*.f64 (/.f64 x z) (log.f64 y))) z z))
	57.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x a) (.f64 z y)) (+.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (*.f64 z y)) (/.f64 i z))) y)) z z))
	64.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (.f64 (neg.f64 b) (-.f64 (/.f64 (neg.f64 (log.f64 c)) z) (/.f64 (+.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) a) z) (/.f64 (+.f64 (fma.f64 (log.f64 y) x (.f64 i y)) t) z)) b)))) z z))
	33.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) (*.f64 b (/.f64 (log.f64 c) z))) z z))
	64.8%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (+.f64 #s(literal -1/2 binary64) b) y) (+.f64 (/.f64 (+.f64 t z) y) (/.f64 (fma.f64 x (log.f64 y) a) y))) i) y))
	31.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (/.f64 (fma.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (+.f64 t z)) y (.f64 (fma.f64 x (log.f64 y) a) y)) (*.f64 y y)) i) y))
	54.0%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (log.f64 y) x a) y) #s(approx (/ (+ ( (log c) (+ -1/2 b)) (+ t z)) y) (/.f64 z y))) i) y))
	56.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 #s(approx (+ (/ (+ ( (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) y)) i) y))
	32.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 #s(approx (+ (/ (+ ( (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) (/.f64 z y)) i) y))
	31.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (+.f64 #s(approx (+ (/ (+ ( (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) (*.f64 b (/.f64 (log.f64 c) y))) i) y))
	16.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
✓	18.2%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))
	10.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ (/ (+ ( (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) (/.f64 (*.f64 (log.f64 y) x) y)) y))
	11.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ (/ (+ ( (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) (/.f64 z y)) y))
	15.3%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ (/ (+ ( (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) (/.f64 a y)) y))
	11.1%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 #s(approx (+ (+ (/ (+ ( (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) (*.f64 b (/.f64 (log.f64 c) y))) y))
✓	22.4%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
✓	22.5%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) z))
	49.9%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (* (+ (+ (/ (+ (* (log y) x) a) y) (/ (+ (* (log c) (+ -1/2 b)) (+ t z)) y)) i) y) (*.f64 (fma.f64 y (/.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) t) a) y) i) x) (log.f64 y)) x)))
✓	24.7%	#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) a)

Compiler

Compiled 4 977 to 1 768 computations (64.5% saved)

regimes372.0ms (3.4%)

Memory

-8.5MiB live, 321.9MiB allocated; 59ms collecting garbage

Counts

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

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

Calls

12 calls:

61.0ms	z
60.0ms	x
50.0ms	(-.f64 b #s(literal 1/2 binary64))
40.0ms	a
21.0ms	c

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)

regimes248.0ms (2.2%)

Memory

-2.4MiB live, 228.3MiB allocated; 18ms collecting garbage

Counts

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

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

Calls

12 calls:

49.0ms	y
39.0ms	c
24.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
23.0ms	t
18.0ms	(log.f64 c)

Results

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

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes241.0ms (2.2%)

Memory

28.0MiB live, 169.1MiB allocated; 11ms collecting garbage

Counts

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

Outputs

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

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

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

Calls

12 calls:

45.0ms	c
40.0ms	z
35.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
13.0ms	y
13.0ms	i

Results

Accuracy	Segments	Branch
85.7%	2	`(log.f64 c)`
84.0%	1	`(-.f64 b #s(literal 1/2 binary64))`
84.0%	1	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
91.1%	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))`
96.4%	3	`x`
91.8%	2	`y`
84.0%	1	`z`
84.0%	1	`t`
88.0%	3	`a`
87.2%	3	`b`
85.7%	2	`c`
93.8%	3	`i`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes21.0ms (0.2%)

Memory

-19.6MiB live, 24.0MiB allocated; 4ms collecting garbage

Counts

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

Outputs

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

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

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

Calls

1 calls:

19.0ms

Results

Accuracy	Segments	Branch
94.5%	3	`x`

Compiler

Compiled 1 to 8 computations (-700% saved)

regimes44.0ms (0.4%)

Memory

16.6MiB live, 62.1MiB allocated; 3ms collecting garbage

Counts

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

Outputs

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

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

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

Calls

3 calls:

19.0ms	i
11.0ms	x
11.0ms	y

Results

Accuracy	Segments	Branch
84.0%	1	`y`
84.0%	1	`i`
92.8%	3	`x`

Compiler

Compiled 3 to 24 computations (-700% saved)

regimes176.0ms (1.6%)

Memory

-20.3MiB live, 213.5MiB allocated; 60ms collecting garbage

Counts

37 → 2

Calls

Call 1

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

Outputs

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

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

Calls

12 calls:

24.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))
20.0ms	t
16.0ms	c
13.0ms	i
10.0ms	a

Results

Accuracy	Segments	Branch
78.2%	2	`z`
80.0%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
69.8%	3	`i`
80.0%	3	`(-.f64 b #s(literal 1/2 binary64))`
75.7%	3	`t`
71.3%	4	`y`
70.0%	3	`(log.f64 c)`
70.0%	3	`c`
80.0%	3	`b`
79.5%	2	`a`
83.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))`
79.0%	4	`x`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes10.0ms (0.1%)

Memory

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

Counts

32 → 2

Calls

Call 1

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

Outputs

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

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

Calls

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

Results

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

Compiler

Compiled 21 to 20 computations (4.8% saved)

regimes59.0ms (0.5%)

Memory

16.0MiB live, 154.2MiB allocated; 17ms collecting garbage

Counts

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

Outputs

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

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

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

Calls

6 calls:

11.0ms	a
11.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
10.0ms	(-.f64 b #s(literal 1/2 binary64))
8.0ms	b
8.0ms	z

Results

Accuracy	Segments	Branch
66.3%	1	`z`
79.5%	3	`(-.f64 b #s(literal 1/2 binary64))`
79.5%	3	`b`
79.7%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
76.6%	2	`a`
76.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))`

Compiler

Compiled 33 to 66 computations (-100% saved)

regimes32.0ms (0.3%)

Memory

-33.0MiB live, 64.2MiB allocated; 11ms collecting garbage

Counts

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

Outputs

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

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

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

Calls

3 calls:

12.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
7.0ms	b
7.0ms	(-.f64 b #s(literal 1/2 binary64))

Results

Accuracy	Segments	Branch
79.1%	3	`(-.f64 b #s(literal 1/2 binary64))`
79.1%	3	`b`
78.9%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`

Compiler

Compiled 10 to 30 computations (-200% saved)

regimes45.0ms (0.4%)

Memory

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

Outputs

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

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

Calls

6 calls:

9.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))
9.0ms	(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
6.0ms	x
6.0ms	b
6.0ms	a

Results

Accuracy	Segments	Branch
66.3%	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))`
72.2%	3	`x`
66.3%	1	`a`
76.0%	3	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
76.1%	3	`(-.f64 b #s(literal 1/2 binary64))`
76.1%	3	`b`

Compiler

Compiled 33 to 66 computations (-100% saved)

regimes58.0ms (0.5%)

Memory

-7.0MiB live, 140.0MiB allocated; 5ms collecting garbage

Counts

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

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

Calls

9 calls:

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

Results

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

Compiler

Compiled 17 to 79 computations (-364.7% saved)

regimes82.0ms (0.7%)

Memory

33.9MiB live, 130.7MiB allocated; 3ms collecting garbage

Counts

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

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

Calls

12 calls:

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

Results

Accuracy	Segments	Branch
60.6%	2	`z`
48.4%	2	`x`
61.7%	2	`a`
65.9%	2	`(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (.f64 x (log.f64 y)) z) t) a) (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))`
54.8%	3	`y`
47.1%	2	`(-.f64 b #s(literal 1/2 binary64))`
48.6%	2	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
58.2%	3	`t`
52.3%	3	`i`
47.4%	2	`(log.f64 c)`
47.1%	2	`b`
47.4%	2	`c`

Compiler

Compiled 40 to 115 computations (-187.5% saved)

regimes10.0ms (0.1%)

Memory

-25.7MiB live, 19.3MiB allocated; 5ms 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)) #s(approx (+ (* (/ (+ (+ (* i y) (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t))) a) z) z) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
(fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) 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)) z)

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

Calls

3 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))
2.0ms	a
2.0ms	z

Results

Accuracy	Segments	Branch
57.7%	2	`z`
50.8%	2	`a`
60.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 23 to 36 computations (-56.5% saved)

regimes6.0ms (0.1%)

Memory

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

Counts

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

3 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))
2.0ms	t
2.0ms	z

Results

Accuracy	Segments	Branch
38.9%	3	`t`
43.5%	3	`z`
57.3%	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 23 to 36 computations (-56.5% saved)

regimes54.0ms (0.5%)

Memory

-2.8MiB live, 42.0MiB allocated; 5ms collecting garbage

Counts

3 → 2

Calls

Call 1

Inputs

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

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

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

10 calls:

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

Results

Accuracy	Segments	Branch
26.6%	2	`(-.f64 b #s(literal 1/2 binary64))`
26.6%	2	`b`
26.8%	2	`(log.f64 c)`
26.8%	2	`c`
28.0%	2	`x`
28.1%	2	`(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))`
28.3%	3	`i`
41.0%	2	`a`
30.4%	3	`y`
46.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 38 to 99 computations (-160.5% saved)

regimes56.0ms (0.5%)

Memory

-10.2MiB live, 37.0MiB 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

12 calls:

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

Results

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

Compiler

Compiled 40 to 115 computations (-187.5% saved)

bsearch54.0ms (0.5%)

Memory

8.8MiB live, 71.3MiB allocated; 12ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
28.0ms	1.8307311548273675e+127	1.7200626996353715e+134
20.0ms	-2.811145698234697e+202	-1.0654763891326644e+195

Samples

29.0ms

288×

valid

Compiler

Compiled 1 428 to 1 075 computations (24.7% saved)

Precisions

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

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

ival-add: 5.0ms (27.3% of total)

ival-mult: 5.0ms (27.3% of total)

ival-sub: 1.0ms (5.5% of total)

ival-true: 0.0ms (0% of total)

adjust: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

bsearch44.0ms (0.4%)

Memory

-15.0MiB live, 77.1MiB allocated; 8ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
25.0ms	7.841854007522227e+141	1.1874455641871985e+153
15.0ms	-2.811145698234697e+202	-1.0654763891326644e+195

Samples

29.0ms

240×

valid

Compiler

Compiled 1 506 to 1 133 computations (24.8% saved)

Precisions

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

ival-log: 8.0ms (40% of total)

ival-mult: 6.0ms (30% of total)

ival-add: 5.0ms (25% of total)

ival-sub: 1.0ms (5% of total)

ival-true: 0.0ms (0% of total)

adjust: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

bsearch65.0ms (0.6%)

Memory

6.8MiB live, 53.3MiB allocated; 3ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
42.0ms	1.2041121446436013e+206	9.312678137911683e+206
18.0ms	-2.811145698234697e+202	-1.0654763891326644e+195

Samples

51.0ms

224×

valid

Compiler

Compiled 939 to 811 computations (13.6% saved)

Precisions

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

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

ival-add: 4.0ms (28.1% of total)

ival-mult: 4.0ms (28.1% of total)

ival-sub: 1.0ms (7% of total)

ival-true: 0.0ms (0% of total)

adjust: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory

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

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-191.94275503436083	-57.166790897619904

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

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

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-6.168746863007833e+35	-267.4108537978511

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

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

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	2.534181213132404e+179	1.9761028366527477e+180
0.0ms	-2.422078069789365e+190	-9.384128746936607e+184

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch39.0ms (0.3%)

Memory

9.9MiB live, 61.4MiB allocated; 5ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
13.0ms	3.975661206665223e+176	3.5404736988954346e+177
21.0ms	-2.1752277480508527e+187	-4.234570734563312e+182

Samples

25.0ms

224×

valid

Compiler

Compiled 1 032 to 787 computations (23.7% saved)

Precisions

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

ival-mult: 6.0ms (36.1% of total)

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

ival-add: 4.0ms (24.1% of total)

ival-sub: 1.0ms (6% of total)

ival-true: 0.0ms (0% of total)

adjust: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

bsearch41.0ms (0.4%)

Memory

-12.3MiB live, 77.6MiB allocated; 10ms collecting garbage

Algorithm

2×	binary-search

Stop Event

1×	narrow-enough
1×	narrow-enough

Steps

Time	Left	Right
23.0ms	5.003307513976274e+222	3.1832884424555813e+227
14.0ms	-8.910498317915828e+219	-2.4573298210809908e+219

Samples

28.0ms

208×

valid

Compiler

Compiled 973 to 746 computations (23.3% saved)

Precisions

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

ival-add: 9.0ms (48.5% of total)

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

ival-mult: 4.0ms (21.6% of total)

ival-sub: 1.0ms (5.4% of total)

ival-true: 0.0ms (0% of total)

adjust: 0.0ms (0% of total)

exact: 0.0ms (0% of total)

ival-assert: 0.0ms (0% of total)

bsearch1.0ms (0%)

Memory

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

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-22.33523399830716	258.78638348294265

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

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

Algorithm

2×	left-value

Steps

Time	Left	Right
0.0ms	14900686918047.105	761764142172176400.0
0.0ms	-1.414904296699182e+305	-4.715506537069129e+303

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

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

Algorithm

3×	left-value

Steps

Time	Left	Right
0.0ms	9.567499350773666e+306	+inf
0.0ms	-22.33523399830716	258.78638348294265
0.0ms	-1.414904296699182e+305	-4.715506537069129e+303

Compiler

Compiled 24 to 31 computations (-29.2% saved)

bsearch1.0ms (0%)

Memory

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

Algorithm

1×	left-value

Steps

Time	Left	Right
0.0ms	-22.33523399830716	258.78638348294265

Compiler

Compiled 24 to 31 computations (-29.2% saved)

simplify85.0ms (0.8%)

Memory

-8.3MiB live, 38.0MiB allocated; 6ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	158	1180
1	227	1180
2	397	1180
3	1047	1180
4	2101	1180
5	2957	1180
6	3040	1180
7	3045	1180
8	3045	1180
9	3382	1180
10	3440	1180
11	3440	1180

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 a (+.f64 t (fma.f64 (log.f64 y) x z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))) a))
(if (<=.f64 x #s(literal -9000000000000000182716967507460562624911423968741767681386860337881695550723562718548470812191328165242345245955993574265936419620615621142644823645415104777424555001630635559876783394632606154752 binary64)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 (+.f64 (+.f64 #s(approx (+ ( (log c) (- b 1/2)) z) z) t) a) x) (log.f64 y)) x))) (if (<=.f64 x #s(literal 299999999999999984073824398788978982500178621509224607521689849393417015904469283815649662851582672919235396975605327422780604416 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 (+.f64 (+.f64 #s(approx (+ ( (log c) (- b 1/2)) z) z) t) a) x) (log.f64 y)) x)))))
(if (<=.f64 x #s(literal -39999999999999998045731698556940528213556641844744866797866335562294046894999836733113551556689360912383501795068553026827793013002209972370542943705105815975081466153493700003108946152916344897536 binary64)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 #s(approx (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) a) x) (log.f64 y)) x))) (if (<=.f64 x #s(literal 1050000000000000083451894193183225223380418638772480878139616948604628707926215895366211738206236283543061889990792898121254712840699179674325774269153280 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 #s(approx (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) a) x) (log.f64 y)) x)))))
(if (<=.f64 x #s(literal -11499999999999999736912984294551894874290900716127752077282700195614995281999780798497148494277577803089164290273682183963238327251792188188981973744865744260690909575334824219298911863872134863388672 binary64)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (log.f64 y) x))) (if (<=.f64 x #s(literal 255000000000000017046675740562219079110210619609470329148140616695487691967919795963471361063646554953171241478842906047079193767835327205168847963563357670173591507035632875182386140997436647363762639077376 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (*.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 -100 binary64)) (fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ ( x (log y)) z) t) a) z))) (fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) 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 -500000000000000021210318687008980992 binary64)) (fma.f64 y i (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) #s(approx (+ (+ (+ ( x (log y)) z) t) a) z))) (fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a))))
(if (<=.f64 (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal -20000000000000001451183431946375567220606848575622745649136687967944203449841378148904136363486483903481251953737351442322669506327274827542980731560078643584425249036505384641606421990866944 binary64)) (fma.f64 y i (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) #s(approx (+ (+ (+ ( x (log y)) z) t) a) z))) (if (<=.f64 (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 500000000000000004624273009945799222283105170828773307953760694316703252854059194654227454321251103268040938522170494571846899043109065616186937831656979356349972484853252378066944 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) z)) (fma.f64 y i (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z)))))
(if (<=.f64 b #s(literal -27999999999999998976401745746519062522013074933679299347863152880835705328850955051537901004033225331865663297646575914352533269552957259350058898246787097733548537766451837087774670848 binary64)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (log.f64 c) b))) (if (<=.f64 b #s(literal 819999999999999983613595038984960396929743311208276880986421292366781513519831388357062395269164436299738363614829124203050302575299538394092936500243817401376585991509740879872 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) z)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (*.f64 (log.f64 c) b)))))
(if (<=.f64 b #s(literal -8500000000000000095127970379188810005367300722452966020232413168871358983065182116501802247331816464179327267848153700885437611449444918813447750319696006739968354600313942229833251621023691522559284400997193494218932224 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (log.f64 c) b)) (if (<=.f64 b #s(literal 3599999999999999808186903184446166024706266140808961204510269690251857461122814570247851653819095240179298937394774730420603255344816981652960488073565049180111785620991420921430285797676181403466990349653993623056365723320320 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) z)) #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)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) 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 -20 binary64)) (fma.f64 y i #s(approx (+ ( (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) z)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) 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 -99999999999999993925355250553646218600402872201173249531907715713232045630132339028433092574405077484368561180561621725787171937426360305302357988408668827749873014416820110410677102531624409058437198025485515990766396825508218326595491122696079498053460349186625724064076043808459598620749043481381437440 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 20000000000000 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) 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 -99999999999999993925355250553646218600402872201173249531907715713232045630132339028433092574405077484368561180561621725787171937426360305302357988408668827749873014416820110410677102531624409058437198025485515990766396825508218326595491122696079498053460349186625724064076043808459598620749043481381437440 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 -20 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 9999999999999999860310597602564577717002641838126363875249660735883565852672743849064846414228960666786379280392654615393353172850252103336275952370615397010730691664689375178569039851073146339641623266071126720011020169553304018596457812688561947201171488461172921822139066929851282122002676667750021070848 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 -20 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 a (+.f64 t (fma.f64 (log.f64 y) x z)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z))) a))
(if (<=.f64 x #s(literal -9000000000000000182716967507460562624911423968741767681386860337881695550723562718548470812191328165242345245955993574265936419620615621142644823645415104777424555001630635559876783394632606154752 binary64)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 (+.f64 (+.f64 #s(approx (+ ( (log c) (- b 1/2)) z) z) t) a) x) (log.f64 y)) x))) (if (<=.f64 x #s(literal 299999999999999984073824398788978982500178621509224607521689849393417015904469283815649662851582672919235396975605327422780604416 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 (+.f64 (+.f64 #s(approx (+ ( (log c) (- b 1/2)) z) z) t) a) x) (log.f64 y)) x)))))
(if (or (<=.f64 x #s(literal -9000000000000000182716967507460562624911423968741767681386860337881695550723562718548470812191328165242345245955993574265936419620615621142644823645415104777424555001630635559876783394632606154752 binary64)) (not (<=.f64 x #s(literal 299999999999999984073824398788978982500178621509224607521689849393417015904469283815649662851582672919235396975605327422780604416 binary64)))) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 (+.f64 (+.f64 #s(approx (+ ( (log c) (- b 1/2)) z) z) t) a) x) (log.f64 y)) x))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))))
(if (<=.f64 x #s(literal -39999999999999998045731698556940528213556641844744866797866335562294046894999836733113551556689360912383501795068553026827793013002209972370542943705105815975081466153493700003108946152916344897536 binary64)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 #s(approx (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) a) x) (log.f64 y)) x))) (if (<=.f64 x #s(literal 1050000000000000083451894193183225223380418638772480878139616948604628707926215895366211738206236283543061889990792898121254712840699179674325774269153280 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 #s(approx (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) a) x) (log.f64 y)) x)))))
(if (or (<=.f64 x #s(literal -39999999999999998045731698556940528213556641844744866797866335562294046894999836733113551556689360912383501795068553026827793013002209972370542943705105815975081466153493700003108946152916344897536 binary64)) (not (<=.f64 x #s(literal 1050000000000000083451894193183225223380418638772480878139616948604628707926215895366211738206236283543061889990792898121254712840699179674325774269153280 binary64)))) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (+.f64 (/.f64 #s(approx (+ (+ (+ ( (log c) (- b 1/2)) z) t) a) a) x) (log.f64 y)) x))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))))
(if (<=.f64 x #s(literal -11499999999999999736912984294551894874290900716127752077282700195614995281999780798497148494277577803089164290273682183963238327251792188188981973744865744260690909575334824219298911863872134863388672 binary64)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (log.f64 y) x))) (if (<=.f64 x #s(literal 255000000000000017046675740562219079110210619609470329148140616695487691967919795963471361063646554953171241478842906047079193767835327205168847963563357670173591507035632875182386140997436647363762639077376 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (*.f64 (log.f64 y) x)))))
(if (or (<=.f64 x #s(literal -11499999999999999736912984294551894874290900716127752077282700195614995281999780798497148494277577803089164290273682183963238327251792188188981973744865744260690909575334824219298911863872134863388672 binary64)) (not (<=.f64 x #s(literal 255000000000000017046675740562219079110210619609470329148140616695487691967919795963471361063646554953171241478842906047079193767835327205168847963563357670173591507035632875182386140997436647363762639077376 binary64)))) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (log.f64 y) x))) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y 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 -100 binary64)) (fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ ( x (log y)) z) t) a) z))) (fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) 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 -500000000000000021210318687008980992 binary64)) (fma.f64 y i (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) #s(approx (+ (+ (+ ( x (log y)) z) t) a) z))) (fma.f64 y i (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) a))))
(if (<=.f64 (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal -20000000000000001451183431946375567220606848575622745649136687967944203449841378148904136363486483903481251953737351442322669506327274827542980731560078643584425249036505384641606421990866944 binary64)) (fma.f64 y i (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) #s(approx (+ (+ (+ ( x (log y)) z) t) a) z))) (if (<=.f64 (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 500000000000000004624273009945799222283105170828773307953760694316703252854059194654227454321251103268040938522170494571846899043109065616186937831656979356349972484853252378066944 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) z)) (fma.f64 y i (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z)))))
(if (or (<=.f64 (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal -20000000000000001451183431946375567220606848575622745649136687967944203449841378148904136363486483903481251953737351442322669506327274827542980731560078643584425249036505384641606421990866944 binary64)) (not (<=.f64 (.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 500000000000000004624273009945799222283105170828773307953760694316703252854059194654227454321251103268040938522170494571846899043109065616186937831656979356349972484853252378066944 binary64)))) (fma.f64 y i (fma.f64 #s(approx (- b 1/2) b) (log.f64 c) #s(approx (+ (+ (+ (* x (log y)) z) t) a) z))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) z)))
(if (<=.f64 b #s(literal -27999999999999998976401745746519062522013074933679299347863152880835705328850955051537901004033225331865663297646575914352533269552957259350058898246787097733548537766451837087774670848 binary64)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (log.f64 c) b))) (if (<=.f64 b #s(literal 819999999999999983613595038984960396929743311208276880986421292366781513519831388357062395269164436299738363614829124203050302575299538394092936500243817401376585991509740879872 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) z)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (*.f64 (log.f64 c) b)))))
(if (or (<=.f64 b #s(literal -27999999999999998976401745746519062522013074933679299347863152880835705328850955051537901004033225331865663297646575914352533269552957259350058898246787097733548537766451837087774670848 binary64)) (not (<=.f64 b #s(literal 819999999999999983613595038984960396929743311208276880986421292366781513519831388357062395269164436299738363614829124203050302575299538394092936500243817401376585991509740879872 binary64)))) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) (.f64 (log.f64 c) b))) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) z)))
(if (<=.f64 b #s(literal -8500000000000000095127970379188810005367300722452966020232413168871358983065182116501802247331816464179327267848153700885437611449444918813447750319696006739968354600313942229833251621023691522559284400997193494218932224 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (.f64 (log.f64 c) b)) (if (<=.f64 b #s(literal 3599999999999999808186903184446166024706266140808961204510269690251857461122814570247851653819095240179298937394774730420603255344816981652960488073565049180111785620991420921430285797676181403466990349653993623056365723320320 binary64)) #s(approx (+ (+ (+ (+ (+ ( x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) z)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 c) b))))
(if (or (<=.f64 b #s(literal -8500000000000000095127970379188810005367300722452966020232413168871358983065182116501802247331816464179327267848153700885437611449444918813447750319696006739968354600313942229833251621023691522559284400997193494218932224 binary64)) (not (<=.f64 b #s(literal 3599999999999999808186903184446166024706266140808961204510269690251857461122814570247851653819095240179298937394774730420603255344816981652960488073565049180111785620991420921430285797676181403466990349653993623056365723320320 binary64)))) #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)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) z)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (+.f64 (fma.f64 i y #s(approx (+ (* (log c) (- b 1/2)) (+ (* (log y) x) t)) t)) a) (/.f64 z z) 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 -20 binary64)) (fma.f64 y i #s(approx (+ ( (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) z)) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) 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 -99999999999999993925355250553646218600402872201173249531907715713232045630132339028433092574405077484368561180561621725787171937426360305302357988408668827749873014416820110410677102531624409058437198025485515990766396825508218326595491122696079498053460349186625724064076043808459598620749043481381437440 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 20000000000000 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) z) (fma.f64 y i #s(approx (+ (* (log c) (- b 1/2)) (+ a (+ t (+ (* (log y) x) z)))) 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 -99999999999999993925355250553646218600402872201173249531907715713232045630132339028433092574405077484368561180561621725787171937426360305302357988408668827749873014416820110410677102531624409058437198025485515990766396825508218326595491122696079498053460349186625724064076043808459598620749043481381437440 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 -20 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 9999999999999999860310597602564577717002641838126363875249660735883565852672743849064846414228960666786379280392654615393353172850252103336275952370615397010730691664689375178569039851073146339641623266071126720011020169553304018596457812688561947201171488461172921822139066929851282122002676667750021070848 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 -20 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)

derivations824.0ms (7.5%)

Memory

16.4MiB live, 683.5MiB allocated; 230ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 1 180 to 165 computations (86% saved)

preprocess117.0ms (1.1%)

Memory: 29.9MiB live, 120.0MiB allocated; 13ms collecting garbage
Remove: (sort z t a)
Compiler: Compiled 2 438 to 404 computations (83.4% saved)

end0.0ms (0%)

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

start0.0ms (0%)

analyze25.0ms (0.2%)

sample2.9s (26.6%)

explain429.0ms (3.9%)

preprocess143.0ms (1.3%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify86.0ms (0.8%)

localize61.0ms (0.5%)

series293.0ms (2.6%)

simplify182.0ms (1.6%)

rewrite233.0ms (2.1%)

eval133.0ms (1.2%)

prune37.0ms (0.3%)

simplify132.0ms (1.2%)

localize126.0ms (1.1%)

series384.0ms (3.5%)

simplify184.0ms (1.7%)

rewrite237.0ms (2.1%)

eval134.0ms (1.2%)

prune48.0ms (0.4%)

simplify168.0ms (1.5%)

localize132.0ms (1.2%)

series333.0ms (3%)

simplify215.0ms (1.9%)

rewrite241.0ms (2.2%)

eval88.0ms (0.8%)

prune62.0ms (0.6%)

simplify128.0ms (1.2%)

localize175.0ms (1.6%)

series362.0ms (3.3%)

simplify208.0ms (1.9%)

rewrite175.0ms (1.6%)

eval106.0ms (1%)

prune62.0ms (0.6%)

regimes372.0ms (3.4%)

regimes248.0ms (2.2%)

regimes241.0ms (2.2%)

regimes21.0ms (0.2%)

regimes44.0ms (0.4%)

regimes176.0ms (1.6%)

regimes10.0ms (0.1%)

regimes59.0ms (0.5%)

regimes32.0ms (0.3%)

regimes45.0ms (0.4%)

regimes58.0ms (0.5%)

regimes82.0ms (0.7%)

regimes10.0ms (0.1%)

regimes6.0ms (0.1%)

regimes54.0ms (0.5%)

regimes56.0ms (0.5%)

bsearch54.0ms (0.5%)

bsearch44.0ms (0.4%)

bsearch65.0ms (0.6%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch39.0ms (0.3%)

bsearch41.0ms (0.4%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

bsearch1.0ms (0%)

simplify85.0ms (0.8%)

derivations824.0ms (7.5%)

preprocess117.0ms (1.1%)

end0.0ms (0%)

Profiling