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

Time bar (total: 13.5s)

start0.0ms (0%)

Memory
0.1MiB live, 0.1MiB allocated

analyze17.0ms (0.1%)

Memory
-9.1MiB live, 29.8MiB allocated
Algorithm
1×search
Search
ProbabilityValidUnknownPreconditionInfiniteDomainCan'tIter
0%0%99.6%0.4%0%0%0%0
0%0%99.6%0.4%0%0%0%1
0%0%99.6%0.4%0%0%0%2
0%0%49.8%0.4%0%49.8%0%3
0%0%49.8%0.4%0%49.8%0%4
0%0%49.8%0.4%0%49.8%0%5
0%0%49.8%0.4%0%49.8%0%6
0%0%49.8%0.4%0%49.8%0%7
100%24.9%0%0.4%0%74.7%0%8
Compiler

Compiled 23 to 22 computations (4.3% saved)

sample1.6s (11.8%)

Memory
15.4MiB live, 2 346.9MiB allocated
Samples
1.0s8 252×0valid
1.0ms4×1valid
Precisions
Click to see histograms. Total time spent on operations: 700.0ms
ival-log: 237.0ms (33.9% of total)
ival-add: 214.0ms (30.6% of total)
ival-mult: 181.0ms (25.9% of total)
ival-sub: 53.0ms (7.6% of total)
ival-true: 7.0ms (1% of total)
exact: 5.0ms (0.7% of total)
ival-assert: 3.0ms (0.4% of total)
adjust: 0.0ms (0% of total)
Bogosity

explain591.0ms (4.4%)

Memory
10.6MiB live, 322.5MiB allocated
FPErrors
Click to see full error table
Ground TruthOverpredictionsExampleUnderpredictionsExampleSubexpression
00-0-a
00-0-(log.f64 y)
00-0-(+.f64 (*.f64 x (log.f64 y)) z)
00-0-t
00-0-(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)
00-0-c
00-0-(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
00-0-y
00-0-i
00-0-(+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t)
00-0-#s(literal 1/2 binary64)
00-0-(log.f64 c)
00-0-(*.f64 x (log.f64 y))
00-0-(+.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))
00-0-z
00-0-(*.f64 y i)
00-0-(-.f64 b #s(literal 1/2 binary64))
00-0-(+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
00-0-b
00-0-x
Confusion
Predicted +Predicted -
+00
-0256
Precision
0/0
Recall
0/0
Confusion?
Predicted +Predicted MaybePredicted -
+000
-00256
Precision?
0/0
Recall?
0/0
Freqs
test
numberfreq
0256
Total Confusion?
Predicted +Predicted MaybePredicted -
+000
-001
Precision?
0/0
Recall?
0/0
Samples
96.0ms510×0valid
2.0ms2×3valid
Compiler

Compiled 215 to 64 computations (70.2% saved)

Precisions
Click to see histograms. Total time spent on operations: 40.0ms
ival-log: 14.0ms (35.1% of total)
ival-add: 11.0ms (27.6% of total)
ival-mult: 10.0ms (25.1% of total)
ival-sub: 3.0ms (7.5% of total)
ival-true: 1.0ms (2.5% of total)
adjust: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)
exact: 0.0ms (0% of total)

preprocess142.0ms (1.1%)

Memory
3.0MiB live, 122.4MiB allocated
Algorithm
1×egg-herbie
Rules
3 874×associate-+r+
3 868×lower-+.f32
3 858×lower-+.f64
1 606×associate-+l+
1 548×+-commutative
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
0244944
1721936
22743930
35497929
47156929
02021
03121
15021
211321
343721
4148921
5179421
6179421
7179421
8179421
9359521
10359521
11379721
12379721
13391721
0391718
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)) a) t)) z))
Symmetry

(sort z t a)

Compiler

Compiled 29 to 20 computations (31% saved)

eval0.0ms (0%)

Memory
0.4MiB live, 0.4MiB allocated
Compiler

Compiled 8 to 8 computations (0% saved)

prune1.0ms (0%)

Memory
1.6MiB live, 1.6MiB allocated
Alt Table
Click to see full alt table
StatusAccuracyProgram
▶99.9%
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
Compiler

Compiled 29 to 20 computations (31% saved)

simplify397.0ms (2.9%)

Memory
-14.1MiB live, 61.0MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
cost-diff0
(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)
cost-diff128
(+.f64 (*.f64 x (log.f64 y)) z)
cost-diff128
(+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
cost-diff128
(+.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))
Rules
3 874×associate-+r+
3 868×lower-+.f32
3 858×lower-+.f64
1 606×associate-+l+
1 548×+-commutative
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
02091
03191
15091
211391
343791
4148991
5179491
6179491
7179491
8179491
9359591
10359591
11379791
12379791
13391791
0391783
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)) a) t)) z))
(+.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

localize109.0ms (0.8%)

Memory
7.6MiB live, 89.5MiB allocated
Localize:

Found 4 expressions of interest:

NewMetricScoreProgram
accuracy0.0078125
(+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a)
accuracy0.01171875
(+.f64 (*.f64 x (log.f64 y)) z)
accuracy0.1484375
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
accuracy0.25390625
(*.f64 x (log.f64 y))
Samples
89.0ms255×0valid
1.0ms1×3valid
Compiler

Compiled 93 to 22 computations (76.3% saved)

Precisions
Click to see histograms. Total time spent on operations: 58.0ms
ival-add: 44.0ms (75.7% of total)
ival-log: 7.0ms (12.1% of total)
ival-mult: 5.0ms (8.6% of total)
ival-sub: 1.0ms (1.7% 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)

series322.0ms (2.4%)

Memory
8.4MiB live, 352.1MiB allocated
Counts
6 → 324
Calls
Call 1
Inputs
#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())
#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())
#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())
#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())
#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())
#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())
Outputs
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.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)) (patch (+.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)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* (log c) (- b 1/2))))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (patch (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) #<representation binary64>) () ())) ())
#s(alt z (taylor 0 x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (log y))) (taylor 0 x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (log y))) (taylor 0 x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (log y))) (taylor 0 x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (/ z x))) (taylor inf x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (/ z x))) (taylor inf x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (/ z x))) (taylor inf x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x))))) (taylor -inf x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x))))) (taylor -inf x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x))))) (taylor -inf x) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (log y))) (taylor 0 y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (log y))) (taylor 0 y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (log y))) (taylor 0 y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (log y))) (taylor 0 y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* -1 (* x (log (/ 1 y))))) (taylor inf y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* -1 (* x (log (/ 1 y))))) (taylor inf y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* -1 (* x (log (/ 1 y))))) (taylor inf y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* -1 (* x (log (/ 1 y))))) (taylor inf y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))) (taylor -inf y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))) (taylor -inf y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))) (taylor -inf y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))) (taylor -inf y) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (log y))) (taylor 0 z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (log y))) (taylor 0 z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (log y))) (taylor 0 z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ (* x (log y)) z))) (taylor inf z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ (* x (log y)) z))) (taylor inf z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ (* x (log y)) z))) (taylor inf z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (*.f64 x (log.f64 y)) z) (patch (+.f64 (*.f64 x (log.f64 y)) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t z)) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x))))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x))))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x))))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x))))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x))))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x))))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y))))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y))))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y))))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* -1 (* x (log (/ 1 y))))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y)))))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (* x (log y)))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (* x (log y)))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (* x (log y)))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* x (log y))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (patch (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 x (log.f64 y)) (patch (*.f64 x (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1/2 (log c)) (taylor 0 b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (log c)) (* b (log c))) (taylor 0 b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (log c)) (* b (log c))) (taylor 0 b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (log c)) (* b (log c))) (taylor 0 b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (* -1/2 (/ (log c) b)))) (taylor inf b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (* -1/2 (/ (log c) b)))) (taylor inf b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (* -1/2 (/ (log c) b)))) (taylor inf b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b))))) (taylor -inf b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b))))) (taylor -inf b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b))))) (taylor -inf b) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* (log c) (- b 1/2)) (taylor 0 c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* (log c) (- b 1/2)) (taylor 0 c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* (log c) (- b 1/2)) (taylor 0 c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* (log c) (- b 1/2)) (taylor 0 c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (log (/ 1 c)) (- b 1/2))) (taylor inf c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (log (/ 1 c)) (- b 1/2))) (taylor inf c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (log (/ 1 c)) (- b 1/2))) (taylor inf c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (log (/ 1 c)) (- b 1/2))) (taylor inf c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) (taylor -inf c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) (taylor -inf c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) (taylor -inf c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
#s(alt (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) (taylor -inf c) (#s(alt (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (patch (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #<representation binary64>) () ())) ())
Calls

81 calls:

TimeVariablePointExpression
155.0ms
y
@0
(+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c)))
45.0ms
c
@0
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
18.0ms
x
@0
(* x (log y))
15.0ms
t
@0
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))
14.0ms
c
@-inf
(+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i))

simplify254.0ms (1.9%)

Memory
26.5MiB live, 206.0MiB allocated
Algorithm
1×egg-herbie
Rules
9 648×lower-fma.f64
9 648×lower-fma.f32
4 536×lower-*.f64
4 536×lower-*.f32
4 236×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
03404983
110744928
237634829
371654829
083364338
Stop Event
1×iter limit
1×node limit
Counts
324 → 303
Calls
Call 1
Inputs
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
z
(+ z (* x (log y)))
(+ z (* x (log y)))
(+ z (* x (log y)))
(* x (log y))
(* x (+ (log y) (/ z x)))
(* x (+ (log y) (/ z x)))
(* x (+ (log y) (/ z x)))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(+ z (* x (log y)))
(+ z (* x (log y)))
(+ z (* x (log y)))
(+ z (* x (log y)))
(+ z (* -1 (* x (log (/ 1 y)))))
(+ z (* -1 (* x (log (/ 1 y)))))
(+ z (* -1 (* x (log (/ 1 y)))))
(+ z (* -1 (* x (log (/ 1 y)))))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(* x (log y))
(+ z (* x (log y)))
(+ z (* x (log y)))
(+ z (* x (log y)))
z
(* z (+ 1 (/ (* x (log y)) z)))
(* z (+ 1 (/ (* x (log y)) z)))
(* z (+ 1 (/ (* x (log y)) z)))
z
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
(+ a (+ t z))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+ a (+ t (* x (log y))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(+ a (+ z (* x (log y))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(+ t (+ z (* x (log y))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
(+ a (+ t (+ z (* x (log y)))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* -1/2 (log c))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(+ (* -1/2 (log c)) (* b (log c)))
(* b (log c))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* (log c) (- b 1/2))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
Outputs
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 a x) (log.f64 y)) (/.f64 t x)) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 i x) y (/.f64 z x)))) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 a x) (log.f64 y)) (/.f64 t x)) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 i x) y (/.f64 z x)))) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 a x) (log.f64 y)) (/.f64 t x)) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 i x) y (/.f64 z x)))) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) x) (log.f64 y)) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) x) (log.f64 y)) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) x) (log.f64 y)) x)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 y i)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) y) x i) (+.f64 (/.f64 t y) (/.f64 a y))) (fma.f64 (/.f64 (log.f64 c) y) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) y) x i) (+.f64 (/.f64 t y) (/.f64 a y))) (fma.f64 (/.f64 (log.f64 c) y) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) y) x i) (+.f64 (/.f64 t y) (/.f64 a y))) (fma.f64 (/.f64 (log.f64 c) y) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z y))) y)
(* i y)
(*.f64 y i)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) y) i) y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) y) i) y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) y) i) y)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 i z) y (fma.f64 (/.f64 (log.f64 c) z) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 x z) (log.f64 y) (/.f64 t z)))) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 i z) y (fma.f64 (/.f64 (log.f64 c) z) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 x z) (log.f64 y) (/.f64 t z)))) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 i z) y (fma.f64 (/.f64 (log.f64 c) z) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 x z) (log.f64 y) (/.f64 t z)))) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 i t) y (fma.f64 (/.f64 (log.f64 c) t) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)))) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 i t) y (fma.f64 (/.f64 (log.f64 c) t) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)))) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 i t) y (fma.f64 (/.f64 (log.f64 c) t) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)))) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) t) t t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) t) t t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) t) t t)
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 i a) y (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 i a) y (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 i a) y (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (/.f64 t b) (/.f64 a b))) (fma.f64 (/.f64 i b) y (fma.f64 (/.f64 x b) (log.f64 y) (/.f64 z b)))) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (/.f64 t b) (/.f64 a b))) (fma.f64 (/.f64 i b) y (fma.f64 (/.f64 x b) (log.f64 y) (/.f64 z b)))) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (/.f64 t b) (/.f64 a b))) (fma.f64 (/.f64 i b) y (fma.f64 (/.f64 x b) (log.f64 y) (/.f64 z b)))) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) z) t) a) b) (log.f64 c)) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) z) t) a) b) (log.f64 c)) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) z) t) a) b) (log.f64 c)) b)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (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))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (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))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (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))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (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))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 y i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 t i)) (fma.f64 (/.f64 x i) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) i) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z i)))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 t i)) (fma.f64 (/.f64 x i) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) i) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z i)))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 t i)) (fma.f64 (/.f64 x i) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) i) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z i)))) i)
(* i y)
(*.f64 y i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) i) y) i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) i) y) i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) i) y) i)
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) 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)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) 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)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) 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)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (log.f64 y) x t) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x z) (log.f64 y) (/.f64 t z)) (fma.f64 (/.f64 (log.f64 c) z) (-.f64 b #s(literal 1/2 binary64)) (/.f64 a z))) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x z) (log.f64 y) (/.f64 t z)) (fma.f64 (/.f64 (log.f64 c) z) (-.f64 b #s(literal 1/2 binary64)) (/.f64 a z))) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x z) (log.f64 y) (/.f64 t z)) (fma.f64 (/.f64 (log.f64 c) z) (-.f64 b #s(literal 1/2 binary64)) (/.f64 a z))) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x t) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) z) z z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x t) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) z) z z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x t) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) z) z z)
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (log.f64 y) x z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)) (fma.f64 (/.f64 (log.f64 c) t) (-.f64 b #s(literal 1/2 binary64)) (/.f64 a t))) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)) (fma.f64 (/.f64 (log.f64 c) t) (-.f64 b #s(literal 1/2 binary64)) (/.f64 a t))) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)) (fma.f64 (/.f64 (log.f64 c) t) (-.f64 b #s(literal 1/2 binary64)) (/.f64 a t))) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) t) t t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) t) t t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) t) t t)
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (log.f64 y) x z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) a a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) a a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) a a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x z)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (fma.f64 (/.f64 x b) (log.f64 y) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (fma.f64 (/.f64 x b) (log.f64 y) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) (+.f64 (+.f64 (fma.f64 (/.f64 x b) (log.f64 y) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x z))) b) (log.f64 c)) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x z))) b) (log.f64 c)) b)
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x z))) b) (log.f64 c)) b)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (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)))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (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)))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (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)))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (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)))
z
(+ z (* x (log y)))
(fma.f64 (log.f64 y) x z)
(+ z (* x (log y)))
(fma.f64 (log.f64 y) x z)
(+ z (* x (log y)))
(fma.f64 (log.f64 y) x z)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (/ z x)))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(* x (+ (log y) (/ z x)))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(* x (+ (log y) (/ z x)))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ z x)))))
(*.f64 (+.f64 (/.f64 z x) (log.f64 y)) x)
(+ z (* x (log y)))
(fma.f64 (log.f64 y) x z)
(+ z (* x (log y)))
(fma.f64 (log.f64 y) x z)
(+ z (* x (log y)))
(fma.f64 (log.f64 y) x z)
(+ z (* x (log y)))
(fma.f64 (log.f64 y) x z)
(+ z (* -1 (* x (log (/ 1 y)))))
(fma.f64 (log.f64 y) x z)
(+ z (* -1 (* x (log (/ 1 y)))))
(fma.f64 (log.f64 y) x z)
(+ z (* -1 (* x (log (/ 1 y)))))
(fma.f64 (log.f64 y) x z)
(+ z (* -1 (* x (log (/ 1 y)))))
(fma.f64 (log.f64 y) x z)
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x z)
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x z)
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x z)
(+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x z)
(* x (log y))
(*.f64 (log.f64 y) x)
(+ z (* x (log y)))
(fma.f64 (log.f64 y) x z)
(+ z (* x (log y)))
(fma.f64 (log.f64 y) x z)
(+ z (* x (log y)))
(fma.f64 (log.f64 y) x z)
z
(* z (+ 1 (/ (* x (log y)) z)))
(fma.f64 (/.f64 (*.f64 (log.f64 y) x) z) z z)
(* z (+ 1 (/ (* x (log y)) z)))
(fma.f64 (/.f64 (*.f64 (log.f64 y) x) z) z z)
(* z (+ 1 (/ (* x (log y)) z)))
(fma.f64 (/.f64 (*.f64 (log.f64 y) x) z) z z)
z
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
(fma.f64 (/.f64 (*.f64 (log.f64 y) x) z) z z)
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
(fma.f64 (/.f64 (*.f64 (log.f64 y) x) z) z z)
(* -1 (* z (- (* -1 (/ (* x (log y)) z)) 1)))
(fma.f64 (/.f64 (*.f64 (log.f64 y) x) z) z z)
(+ a (+ t z))
(+.f64 (+.f64 z t) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ z x)))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 z t) a) x) (log.f64 y)) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 z t) a) x) (log.f64 y)) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t z)) x)))))
(*.f64 (+.f64 (/.f64 (+.f64 (+.f64 z t) a) x) (log.f64 y)) x)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* -1 (* x (log (/ 1 y)))))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x z))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x z))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x z))
(+ a (+ t (+ z (* x (+ (log -1) (* -1 (log (/ -1 y))))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x z))
(+ a (+ t (* x (log y))))
(+.f64 (fma.f64 (log.f64 y) x t) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x z) (log.f64 y) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x z) (log.f64 y) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (/ (* x (log y)) z)))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x z) (log.f64 y) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) z z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) z z)
(* -1 (* z (- (* -1 (/ (+ a (+ t (* x (log y)))) z)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x t) a) z) z z)
(+ a (+ z (* x (log y))))
(+.f64 (fma.f64 (log.f64 y) x z) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (/ (* x (log y)) t)))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) a) t) t t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) a) t) t t)
(* -1 (* t (- (* -1 (/ (+ a (+ z (* x (log y)))) t)) 1)))
(fma.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x z) a) t) t t)
(+ t (+ z (* x (log y))))
(fma.f64 (log.f64 y) x (+.f64 z t))
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
(+ a (+ t (+ z (* x (log y)))))
(+.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a)
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))
(fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(fma.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a) a a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(fma.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a) a a)
(* -1 (* a (- (* -1 (/ (+ t (+ z (* x (log y)))) a)) 1)))
(fma.f64 (/.f64 (fma.f64 (log.f64 y) x (+.f64 z t)) a) a a)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* -1/2 (log c))
(*.f64 #s(literal -1/2 binary64) (log.f64 c))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(+ (* -1/2 (log c)) (* b (log c)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b)
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b)
(* b (+ (log c) (* -1/2 (/ (log c) b))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b)
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b)
(* -1 (* b (+ (* -1 (log c)) (* 1/2 (/ (log c) b)))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (log.f64 c)) b)
(* (log c) (- b 1/2))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(* (log c) (- b 1/2))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(* (log c) (- b 1/2))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(* (log c) (- b 1/2))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(* -1 (* (log (/ 1 c)) (- b 1/2)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)))
(* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)))

rewrite531.0ms (3.9%)

Memory
-224.0MiB live, 317.2MiB allocated
Rules
4 964×lower-*.f32
4 958×lower-*.f64
4 642×lower-fma.f64
4 642×lower-fma.f32
3 742×lower-/.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
02064
03164
112564
2116064
0823357
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
6 → 406
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 (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 i y) i) y)) (/.f64 #s(literal 1 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 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (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 #s(literal 1 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)))))
(pow.f64 (/.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 (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 i y) i) y))) #s(literal -1 binary64))
(pow.f64 (/.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 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (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)))) #s(literal -1 binary64))
(/.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 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))) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 (*.f64 (*.f64 i y) 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))) #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 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 (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))) (fma.f64 (/.f64 (*.f64 (*.f64 (*.f64 i y) 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 (*.f64 (*.f64 (*.f64 i y) 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 (/.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 (*.f64 i y) 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 (+.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 (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 (*.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 (fma.f64 (*.f64 a a) a (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 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 (*.f64 (*.f64 (*.f64 i y) i) y) (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 (+.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)) (*.f64 (*.f64 (*.f64 i y) i) y)))) (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 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (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)) (*.f64 (*.f64 (*.f64 i y) 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)) (-.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 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y)) (-.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)) (*.f64 (*.f64 (*.f64 i y) i) y)) (-.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)) (*.f64 (+.f64 a t) (+.f64 a t))))) (*.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)) (*.f64 (*.f64 (*.f64 i y) i) y)) (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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)) #s(literal 1 binary64))) (*.f64 (-.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 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) 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))) (fma.f64 (*.f64 a a) a (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)) #s(literal 1 binary64))) (*.f64 (-.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))) (fma.f64 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y)) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.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)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (*.f64 i y) i) y)) (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)) (*.f64 (*.f64 (*.f64 i y) 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 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)) (neg.f64 (fma.f64 (*.f64 a a) a (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)) (*.f64 (*.f64 (*.f64 i y) i) y)) (-.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)) (*.f64 (*.f64 (*.f64 i y) 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 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)) (fma.f64 (*.f64 a a) a (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)) (*.f64 (*.f64 (*.f64 i y) 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 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)) (fma.f64 (*.f64 a a) a (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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y))) (-.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y))) (-.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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 (+.f64 a t) (+.f64 a t))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y))) (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (fma.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) 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))) (fma.f64 (*.f64 a a) a (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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)))) #s(literal 1 binary64))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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))) (fma.f64 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t))))) (*.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y))) (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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) 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 (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)))) (neg.f64 (fma.f64 (*.f64 a a) a (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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y))) (-.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) 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 (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)))) (fma.f64 (*.f64 a a) a (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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) 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 (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)))) (fma.f64 (*.f64 a a) a (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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i y) i) y)))) (*.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) 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)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (+.f64 a t) (+.f64 a t))) (-.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)) (*.f64 (*.f64 (*.f64 i y) i) y)))) (*.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)) (*.f64 (+.f64 a t) (+.f64 a t))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) 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)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y))))))
(/.f64 (fma.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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 (*.f64 (*.f64 i y) i) y)))) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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 (fma.f64 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)))) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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 3 binary64)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y))))) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y))))))
(/.f64 (fma.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)) (*.f64 (/.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 (*.f64 a a) a (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 (*.f64 (*.f64 i y) i) y)))) (*.f64 (/.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 (*.f64 a a) a (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 #s(literal 1 binary64) (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y)))) (*.f64 (/.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 (*.f64 a a) a (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 3 binary64)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y))))) (*.f64 (/.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 (*.f64 a a) a (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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t))) (-.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 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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 (*.f64 (*.f64 i y) i) y)))) (*.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t))) (+.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y))))) (*.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i y) i) y)))) (*.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) 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)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y))))))
(/.f64 (fma.f64 (neg.f64 (fma.f64 (*.f64 a a) a (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)) (*.f64 (*.f64 (*.f64 i y) 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 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y))))
(/.f64 (fma.f64 (neg.f64 (fma.f64 (*.f64 a a) a (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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) 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)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i y) i) y)))) (*.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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) 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)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y))))))
(/.f64 (fma.f64 (fma.f64 (*.f64 a a) a (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)) (*.f64 (*.f64 (*.f64 i y) 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 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y))))
(/.f64 (fma.f64 (fma.f64 (*.f64 a a) a (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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) 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)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y))))))
(/.f64 (fma.f64 (fma.f64 (*.f64 a a) a (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)) (*.f64 (*.f64 (*.f64 i y) 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 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y))))
(/.f64 (fma.f64 (fma.f64 (*.f64 a a) a (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 (*.f64 (*.f64 (*.f64 i y) i) y) (*.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)) (*.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) 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)) (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (*.f64 i y))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.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 (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 i y) i) y)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.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 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (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 (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (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 #s(literal 1 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 (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 i y) i) y))))
(/.f64 #s(literal 1 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 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (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 (+.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)) (*.f64 (*.f64 (*.f64 i y) i) y))) (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 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (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 (*.f64 i y) i) y (-.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 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (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)) (*.f64 (*.f64 (*.f64 i y) 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 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (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 (*.f64 i y) i) y (-.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 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (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 (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)))
(fma.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (log.f64 y) x z) t)) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a) (*.f64 i y)))
(fma.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (log.f64 y) x z) t)) (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y))))
(fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 (*.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))))
(fma.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 #s(literal 1 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 i y))
(fma.f64 (fma.f64 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))) (/.f64 #s(literal 1 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 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)))
(fma.f64 (fma.f64 (*.f64 t t) t (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64))) (/.f64 #s(literal 1 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 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a) (*.f64 i y)))
(fma.f64 (fma.f64 (*.f64 t t) t (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64))) (/.f64 #s(literal 1 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 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y))))
(fma.f64 (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))) (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y))))
(fma.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 #s(literal 1 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 i y))
(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 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 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 (*.f64 (*.f64 (*.f64 i y) 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)))))) (/.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 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 (*.f64 i y) 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 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 (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 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 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 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 (+.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 #s(literal 1 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 #s(literal 1 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)))))
(pow.f64 (/.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 (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)))) #s(literal -1 binary64))
(pow.f64 (/.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 (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)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.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))))) #s(literal 3 binary64)) (pow.f64 (/.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))))) #s(literal 3 binary64))) (fma.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 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))))) (fma.f64 (/.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 (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 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 (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)) (*.f64 (*.f64 a a) a)) (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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t))) (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 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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 (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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 t t) t (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 (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 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 (-.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)) (*.f64 (+.f64 t z) (+.f64 t z))))) (*.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 (-.f64 (fma.f64 (log.f64 y) x z) t) (-.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)))) #s(literal 1 binary64))) (*.f64 (-.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (/.f64 (-.f64 (fma.f64 (log.f64 y) x z) t) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (*.f64 t 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))) (/.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 (*.f64 t t) t (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)))) #s(literal 1 binary64))) (*.f64 (-.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))) (fma.f64 (*.f64 t t) t (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 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 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.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)) (*.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (+.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)) (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.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 (fma.f64 (*.f64 t t) t (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)))) (fma.f64 (*.f64 t t) t (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)))) (fma.f64 (*.f64 t t) t (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 (fma.f64 (*.f64 a a) a (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)) (*.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 (fma.f64 a a (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.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 (fma.f64 (*.f64 a a) a (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)) (*.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 (+.f64 t z) (+.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)) (*.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 (fma.f64 (*.f64 a a) a (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) (-.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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) #s(literal 1 binary64))) (*.f64 (fma.f64 a a (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (/.f64 (-.f64 (fma.f64 (log.f64 y) x z) t) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (*.f64 t t)))))
(/.f64 (fma.f64 (fma.f64 (*.f64 a a) a (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 (*.f64 t t) t (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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) #s(literal 1 binary64))) (*.f64 (fma.f64 a a (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 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))) (fma.f64 (*.f64 t t) t (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64))))))
(/.f64 (fma.f64 (fma.f64 (*.f64 a a) a (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 (*.f64 (+.f64 t z) (+.f64 t z)) (*.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)) (*.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)) (*.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (+.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)) (*.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 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 (*.f64 (log.f64 y) x) (+.f64 t z))))))
(/.f64 (fma.f64 (fma.f64 (*.f64 a a) a (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)) (*.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 (fma.f64 a a (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.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 (fma.f64 (*.f64 a a) a (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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (neg.f64 (fma.f64 (*.f64 t t) t (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)) (*.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 (fma.f64 (*.f64 a a) a (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)) (*.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 (fma.f64 a a (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.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 (fma.f64 (*.f64 a a) a (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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (fma.f64 (*.f64 t t) t (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)) (*.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 (fma.f64 (*.f64 a a) a (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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (fma.f64 (*.f64 t t) t (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)) (*.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 (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)) (*.f64 (+.f64 a t) (+.f64 a t))))) (*.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 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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) #s(literal 1 binary64))) (*.f64 (+.f64 #s(literal 1/2 binary64) b) (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (fma.f64 (*.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))) (fma.f64 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64)))) (*.f64 (+.f64 #s(literal 1/2 binary64) b) #s(literal 1 binary64))) (*.f64 (+.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))) (fma.f64 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))))))
(/.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 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.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)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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 (fma.f64 (*.f64 a a) a (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) (fma.f64 (*.f64 a a) a (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) (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 b b) b #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)) (*.f64 (+.f64 a t) (+.f64 a t))))) (*.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 (fma.f64 (*.f64 b b) b #s(literal -1/8 binary64)) (log.f64 c)) (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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))) #s(literal 1 binary64))) (*.f64 (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 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (fma.f64 (*.f64 (fma.f64 (*.f64 b b) b #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 (*.f64 a a) a (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))) #s(literal 1 binary64))) (*.f64 (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))) (fma.f64 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))))))
(/.f64 (fma.f64 (*.f64 (fma.f64 (*.f64 b b) b #s(literal -1/8 binary64)) (log.f64 c)) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.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)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 (fma.f64 (log.f64 y) x z) (+.f64 a t))))))
(/.f64 (fma.f64 (*.f64 (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 b b) b #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))) (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 b b) b #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))) (fma.f64 (*.f64 a a) a (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)) (*.f64 (+.f64 a t) (+.f64 a t))))) (*.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 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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) #s(literal 1 binary64))) (*.f64 (+.f64 #s(literal 1/2 binary64) b) (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (fma.f64 (*.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))) (fma.f64 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64)))) (*.f64 (+.f64 #s(literal 1/2 binary64) b) #s(literal 1 binary64))) (*.f64 (+.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))) (fma.f64 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))))))
(/.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 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.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)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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 (fma.f64 (*.f64 a a) a (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) (fma.f64 (*.f64 a a) a (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) (fma.f64 (*.f64 a a) a (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) (fma.f64 (*.f64 b b) b #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) (fma.f64 (*.f64 b b) b #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)) (*.f64 (+.f64 a t) (+.f64 a t))))) (*.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) (fma.f64 (*.f64 b b) b #s(literal -1/8 binary64))) (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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))) #s(literal 1 binary64))) (*.f64 (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 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 (fma.f64 (*.f64 (log.f64 c) (fma.f64 (*.f64 b b) b #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 (*.f64 a a) a (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))) #s(literal 1 binary64))) (*.f64 (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))) (fma.f64 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))))))
(/.f64 (fma.f64 (*.f64 (log.f64 c) (fma.f64 (*.f64 b b) b #s(literal -1/8 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.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)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 (fma.f64 (log.f64 y) x z) (+.f64 a t))))))
(/.f64 (fma.f64 (*.f64 (log.f64 c) (fma.f64 (*.f64 b b) b #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) (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 a a) a (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) (fma.f64 (*.f64 b b) b #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) (fma.f64 (*.f64 b b) b #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))) (fma.f64 (*.f64 a a) a (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) (fma.f64 (*.f64 b b) b #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))) (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 b b) b #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) (fma.f64 (*.f64 b b) b #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)) (*.f64 (+.f64 a t) (+.f64 a t))) (+.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)) (*.f64 (+.f64 a t) (+.f64 a t))) (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 (fma.f64 (*.f64 b b) b #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)) (*.f64 (+.f64 a t) (+.f64 a t))) (+.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)) (*.f64 (+.f64 a t) (+.f64 a t))) (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) (fma.f64 (*.f64 b b) b #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 #s(literal 1 binary64) (+.f64 #s(literal 1/2 binary64) b) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (fma.f64 b b #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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 (fma.f64 #s(literal 1 binary64) (fma.f64 b b (fma.f64 #s(literal 1/2 binary64) b #s(literal 1/4 binary64))) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (fma.f64 (*.f64 b b) b #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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 (fma.f64 #s(literal 1 binary64) (+.f64 #s(literal 1/2 binary64) b) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (log.f64 c) (fma.f64 b b #s(literal -1/4 binary64))))) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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 (fma.f64 #s(literal 1 binary64) (fma.f64 b b (fma.f64 #s(literal 1/2 binary64) b #s(literal 1/4 binary64))) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a))) (*.f64 (log.f64 c) (fma.f64 (*.f64 b b) b #s(literal -1/8 binary64))))) (*.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.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 (fma.f64 #s(literal 1 binary64) (+.f64 #s(literal 1/2 binary64) b) (*.f64 (/.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 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64)))) (*.f64 (fma.f64 b b #s(literal -1/4 binary64)) (log.f64 c)))) (*.f64 (/.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 (*.f64 a a) a (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 #s(literal 1 binary64) (fma.f64 b b (fma.f64 #s(literal 1/2 binary64) b #s(literal 1/4 binary64))) (*.f64 (/.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 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64)))) (*.f64 (fma.f64 (*.f64 b b) b #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (/.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 (*.f64 a a) a (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 #s(literal 1 binary64) (+.f64 #s(literal 1/2 binary64) b) (*.f64 (/.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 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64)))) (*.f64 (log.f64 c) (fma.f64 b b #s(literal -1/4 binary64))))) (*.f64 (/.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 (*.f64 a a) a (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 #s(literal 1 binary64) (fma.f64 b b (fma.f64 #s(literal 1/2 binary64) b #s(literal 1/4 binary64))) (*.f64 (/.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 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64)))) (*.f64 (log.f64 c) (fma.f64 (*.f64 b b) b #s(literal -1/8 binary64))))) (*.f64 (/.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 (*.f64 a a) a (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 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t))) (+.f64 #s(literal 1/2 binary64) b) (*.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t))) (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 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 (fma.f64 (log.f64 y) x z) (+.f64 a t)))) (*.f64 (fma.f64 (*.f64 b b) b #s(literal -1/8 binary64)) (log.f64 c)))) (*.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t))) (+.f64 #s(literal 1/2 binary64) b) (*.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t))) (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 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 (fma.f64 (log.f64 y) x z) (+.f64 a t)))) (*.f64 (log.f64 c) (fma.f64 (*.f64 b b) b #s(literal -1/8 binary64))))) (*.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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 (fma.f64 (*.f64 b b) b #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) (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 a a) a (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) (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 b b) b #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) (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 a a) a (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) (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 a a) a (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) (fma.f64 (*.f64 b b) b #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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (*.f64 (-.f64 t (fma.f64 (log.f64 y) x z)) (fma.f64 (*.f64 a a) a (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)) (*.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)) (*.f64 (+.f64 t z) (+.f64 t z))) (-.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)) (*.f64 (+.f64 t z) (+.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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (*.f64 (-.f64 (*.f64 (log.f64 y) x) (+.f64 t z)) (fma.f64 (*.f64 a a) a (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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (fma.f64 #s(literal 1 binary64) (-.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (*.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x z) t) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (*.f64 t t))) (-.f64 (*.f64 a a) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))))) (*.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x z) t) (-.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 (fma.f64 #s(literal 1 binary64) (fma.f64 a a (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (*.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x z) t) (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (*.f64 t t))) (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))))) (*.f64 (/.f64 (-.f64 (fma.f64 (log.f64 y) x z) t) (-.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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (fma.f64 #s(literal 1 binary64) (-.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) (*.f64 (/.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 (*.f64 t t) t (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64)))) (-.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 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 (*.f64 t t) t (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 #s(literal 1 binary64) (fma.f64 a a (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (*.f64 (/.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 (*.f64 t t) t (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64)))) (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))))) (*.f64 (/.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 (*.f64 t t) t (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)) (*.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)) (*.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (+.f64 t z))) (-.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 (*.f64 (+.f64 t z) (+.f64 t z)) (*.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 (*.f64 (+.f64 t z) (+.f64 t z)) (*.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)) (*.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (+.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)) (*.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 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 (*.f64 (log.f64 y) x) (+.f64 t z)))) (fma.f64 (*.f64 a a) a (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 (*.f64 (+.f64 t z) (+.f64 t z)) (*.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)) (*.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))) (-.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)) (*.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)) (fma.f64 (*.f64 a a) a (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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (fma.f64 (neg.f64 (fma.f64 (*.f64 t t) t (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 (fma.f64 (*.f64 t t) t (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)) (*.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)))) (fma.f64 (*.f64 a a) a (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)) (*.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)) (-.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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))) (*.f64 (-.f64 (fma.f64 (log.f64 y) x z) t) (fma.f64 (*.f64 a a) a (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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (fma.f64 (fma.f64 (*.f64 t t) t (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 (fma.f64 (*.f64 t t) t (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)) (*.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)))) (fma.f64 (*.f64 a a) a (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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (fma.f64 (fma.f64 (*.f64 t t) t (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 (fma.f64 (*.f64 t t) t (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)) (*.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))) (fma.f64 (*.f64 a a) a (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)) (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.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 (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 #s(literal -1 binary64) (neg.f64 (/.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 (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 (-.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 #s(literal 1 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)))) (-.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 #s(literal 1 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))) (+.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 (+.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 (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a)) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (log.f64 y) x z) t)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a))
(fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 y) x) z)) (+.f64 (+.f64 a t) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 y) x) z)) (+.f64 t (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a)))
(fma.f64 (fma.f64 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))) (/.f64 #s(literal 1 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 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (fma.f64 (*.f64 t t) t (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64))) (/.f64 #s(literal 1 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)))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a))
(fma.f64 (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))) (+.f64 (+.f64 a t) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(fma.f64 (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))) (+.f64 t (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a)))
(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 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 (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 (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 (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 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 (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 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 y) x) z)))
(*.f64 (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) z) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 y) x) z)) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 z z) (-.f64 (*.f64 (log.f64 y) x) z)) #s(literal 3 binary64))) (fma.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 y) x) z)) (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 y) x) z)) (fma.f64 (/.f64 (*.f64 z z) (-.f64 (*.f64 (log.f64 y) x) z)) (/.f64 (*.f64 z z) (-.f64 (*.f64 (log.f64 y) x) z)) (*.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 (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 (fma.f64 (*.f64 z z) z (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 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) z) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 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 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (log.f64 y) x) z) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z))))
(/.f64 #s(literal 1 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 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))))
(/.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 (fma.f64 (*.f64 z z) z (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 (fma.f64 (*.f64 z z) z (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 (fma.f64 (*.f64 z z) z (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 (fma.f64 (*.f64 z z) z (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 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) z)
(*.f64 (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a)))
(*.f64 (fma.f64 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))) (/.f64 #s(literal 1 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)))))
(pow.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a))) #s(literal -1 binary64))
(pow.f64 (/.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 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.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)) #s(literal 3 binary64)) (pow.f64 (/.f64 (*.f64 a a) (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a)) #s(literal 3 binary64))) (fma.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 (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)) (fma.f64 (/.f64 (*.f64 a a) (-.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 (+.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 (+.f64 a (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64)) (*.f64 (*.f64 t t) t)) (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)) (*.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (+.f64 t z))) (fma.f64 (+.f64 a (*.f64 (log.f64 y) x)) (+.f64 a (*.f64 (log.f64 y) x)) (-.f64 (*.f64 (+.f64 t z) (+.f64 t z)) (*.f64 (+.f64 a (*.f64 (log.f64 y) x)) (+.f64 t z)))))
(/.f64 (fma.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t) (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64))) (fma.f64 (+.f64 a t) (+.f64 a t) (-.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 (fma.f64 (*.f64 t t) t (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 (fma.f64 (*.f64 z z) z (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)) (*.f64 (+.f64 a t) (+.f64 a t)))) (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)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t)))) (neg.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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 (fma.f64 (*.f64 a a) a (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 (-.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)) (/.f64 (-.f64 (*.f64 (log.f64 y) x) z) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z))) (*.f64 (-.f64 t a) #s(literal 1 binary64))) (*.f64 (-.f64 t a) (/.f64 (-.f64 (*.f64 (log.f64 y) x) z) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z)))))
(/.f64 (fma.f64 (-.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))) (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) (*.f64 (-.f64 t a) #s(literal 1 binary64))) (*.f64 (-.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))) (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))))))
(/.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 (fma.f64 (*.f64 z z) z (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) (fma.f64 (*.f64 z z) z (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) (fma.f64 (*.f64 z z) z (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 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (-.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 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (/.f64 (-.f64 (*.f64 (log.f64 y) x) z) (-.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))) #s(literal 1 binary64))) (*.f64 (fma.f64 t t (-.f64 (*.f64 a a) (*.f64 t a))) (/.f64 (-.f64 (*.f64 (log.f64 y) x) z) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z)))))
(/.f64 (fma.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (/.f64 (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) (*.f64 (fma.f64 t t (-.f64 (*.f64 a a) (*.f64 t a))) #s(literal 1 binary64))) (*.f64 (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))) (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))))))
(/.f64 (fma.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (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 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a 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 (fma.f64 t t (-.f64 (*.f64 a a) (*.f64 t a))) (neg.f64 (fma.f64 (*.f64 z z) z (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 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (-.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 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a 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 (fma.f64 t t (-.f64 (*.f64 a a) (*.f64 t a))) (fma.f64 (*.f64 z z) z (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 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) 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 t t (-.f64 (*.f64 a a) (*.f64 t a))) (fma.f64 (*.f64 z z) z (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)) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)))) (*.f64 (-.f64 z (*.f64 (log.f64 y) x)) (fma.f64 t t (-.f64 (*.f64 a a) (*.f64 t a)))))
(/.f64 (fma.f64 #s(literal 1 binary64) (-.f64 t a) (*.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) z) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z))) (-.f64 (*.f64 t t) (*.f64 a a)))) (*.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) z) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z))) (-.f64 t a)))
(/.f64 (fma.f64 #s(literal 1 binary64) (fma.f64 t t (-.f64 (*.f64 a a) (*.f64 t a))) (*.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) z) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z))) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)))) (*.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) z) (-.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 (fma.f64 #s(literal 1 binary64) (-.f64 t a) (*.f64 (/.f64 (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) (-.f64 (*.f64 t t) (*.f64 a a)))) (*.f64 (/.f64 (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) (-.f64 t a)))
(/.f64 (fma.f64 #s(literal 1 binary64) (fma.f64 t t (-.f64 (*.f64 a a) (*.f64 t a))) (*.f64 (/.f64 (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)))) (*.f64 (/.f64 (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 (*.f64 z z) z (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 (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)) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)))) (*.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 (fma.f64 (*.f64 z z) z (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 (fma.f64 (*.f64 z z) z (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)))) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a 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)))) (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) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)))) (*.f64 (-.f64 (*.f64 (log.f64 y) x) z) (fma.f64 t t (-.f64 (*.f64 a a) (*.f64 t a)))))
(/.f64 (fma.f64 (fma.f64 (*.f64 z z) z (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 (fma.f64 (*.f64 z z) z (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)))) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a 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)))) (fma.f64 t t (-.f64 (*.f64 a a) (*.f64 t a)))))
(/.f64 (fma.f64 (fma.f64 (*.f64 z z) z (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 (fma.f64 (*.f64 z z) z (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))) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)))) (*.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 #s(literal -1 binary64) (neg.f64 (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.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 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64))))))
(/.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)) (*.f64 (+.f64 a t) (+.f64 a t))) (-.f64 (fma.f64 (log.f64 y) x z) (+.f64 a t)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) a) (-.f64 (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (*.f64 a a))))
(/.f64 #s(literal 1 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 (*.f64 a a) a (pow.f64 (+.f64 t (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 a a) a (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 (fma.f64 (*.f64 a a) a (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 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (log.f64 y) x z) t)) a)
(fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 y) x) z)) (+.f64 a t))
(fma.f64 (fma.f64 (*.f64 t t) t (pow.f64 (fma.f64 (log.f64 y) x z) #s(literal 3 binary64))) (/.f64 #s(literal 1 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)))) a)
(fma.f64 (fma.f64 (*.f64 z z) z (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))) (+.f64 a t))
(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 (*.f64 (+.f64 a t) (+.f64 a t)) (-.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 a (fma.f64 (log.f64 y) x z)) t)
(+.f64 (+.f64 a (*.f64 (log.f64 y) x)) (+.f64 t z))
(+.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 c) (-.f64 b #s(literal 1/2 binary64)))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(/.f64 (+.f64 (pow.f64 (*.f64 b (log.f64 c)) #s(literal 3 binary64)) (pow.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 c)) #s(literal 3 binary64))) (fma.f64 (*.f64 b (log.f64 c)) (*.f64 b (log.f64 c)) (-.f64 (*.f64 (*.f64 #s(literal -1/2 binary64) (log.f64 c)) (*.f64 #s(literal -1/2 binary64) (log.f64 c))) (*.f64 (*.f64 b (log.f64 c)) (*.f64 #s(literal -1/2 binary64) (log.f64 c))))))
(/.f64 (+.f64 (pow.f64 (*.f64 (log.f64 c) b) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) #s(literal 3 binary64))) (fma.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) b) (-.f64 (*.f64 (*.f64 (log.f64 c) #s(literal -1/2 binary64)) (*.f64 (log.f64 c) #s(literal -1/2 binary64))) (*.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #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 (fma.f64 (*.f64 b b) b #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) (fma.f64 (*.f64 b b) b #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 (fma.f64 (*.f64 b b) b #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) (fma.f64 (*.f64 b b) b #s(literal -1/8 binary64))) (fma.f64 b b (fma.f64 #s(literal 1/2 binary64) b #s(literal 1/4 binary64))))
(fma.f64 (log.f64 c) b (*.f64 (log.f64 c) #s(literal -1/2 binary64)))
(fma.f64 b (log.f64 c) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
(+.f64 (*.f64 b (log.f64 c)) (*.f64 #s(literal -1/2 binary64) (log.f64 c)))
(+.f64 (*.f64 (log.f64 c) b) (*.f64 (log.f64 c) #s(literal -1/2 binary64)))

eval96.0ms (0.7%)

Memory
38.4MiB live, 267.2MiB allocated
Compiler

Compiled 32 509 to 2 146 computations (93.4% saved)

prune154.0ms (1.1%)

Memory
7.0MiB live, 316.5MiB allocated
Pruning

19 alts after pruning (19 fresh and 0 done)

PrunedKeptTotal
New69019709
Fresh000
Picked101
Done000
Total69119710
Accuracy
100.0%
Counts
710 → 19
Alt Table
Click to see full alt table
StatusAccuracyProgram
71.9%
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (/.f64 (*.f64 (fma.f64 b b #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 #s(literal 1/2 binary64) b))) (*.f64 y i))
67.8%
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (fma.f64 (+.f64 (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)) (/.f64 a t)) t t)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
61.8%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)) (fma.f64 (/.f64 (log.f64 c) t) (-.f64 b #s(literal 1/2 binary64)) (/.f64 a t))) t t)) (*.f64 y i))
80.3%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i))
75.8%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x z))) b) (log.f64 c)) b)) (*.f64 y i))
▶70.3%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
▶37.4%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i))
44.2%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.f64 y i))
63.7%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) t) t t))
▶78.9%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z))
79.8%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a))
▶85.8%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
76.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
72.6%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) x) (log.f64 y)) x))
71.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) y) x i) (+.f64 (/.f64 t y) (/.f64 a y))) (fma.f64 (/.f64 (log.f64 c) y) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z y))) y))
67.1%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 t i)) (fma.f64 (/.f64 x i) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) i) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z i)))) i))
14.9%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
▶24.4%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
22.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
Compiler

Compiled 1 058 to 670 computations (36.7% saved)

simplify200.0ms (1.5%)

Memory
36.1MiB live, 251.2MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 18 expressions of interest:

NewMetricScoreProgram
cost-diff0
(+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
cost-diff0
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
cost-diff128
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
cost-diff2944
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
cost-diff0
(+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
cost-diff0
(/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
cost-diff0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z))
cost-diff896
(fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)
cost-diff0
(log.f64 y)
cost-diff0
(*.f64 (log.f64 y) x)
cost-diff0
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))
cost-diff128
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i))
cost-diff0
(*.f64 y i)
cost-diff0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
cost-diff0
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))
cost-diff0
(+.f64 t a)
cost-diff0
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))
cost-diff0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
Rules
14 884×lower-fma.f32
14 870×lower-fma.f64
3 552×lower-*.f32
3 546×lower-*.f64
2 742×lower-+.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
051527
079527
1141520
2334508
31250504
42343504
53436477
63894477
75804477
87842477
08012475
Stop Event
1×iter limit
1×node limit
1×iter limit
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))
(+.f64 t a)
t
a
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
(fma.f64 y i z)
y
i
z
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
(*.f64 y i)
y
i
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(log.f64 y)
y
x
(*.f64 y i)
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)
(/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
y
i
(fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
(log.f64 y)
x
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
t
a
z
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x))
(+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x))
(fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))
(/.f64 (log.f64 c) x)
(log.f64 c)
c
x
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(/.f64 z x)
z
(/.f64 t x)
t
(/.f64 a x)
a
(log.f64 y)
y
(*.f64 y i)
i
Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 i y (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) z) a)))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))
(fma.f64 i y (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) z) a))
(+.f64 t a)
(+.f64 a t)
t
a
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
(fma.f64 y i z)
(fma.f64 i y z)
y
i
z
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))
(*.f64 y i)
(*.f64 i y)
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 i 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))) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(log.f64 y)
y
x
(*.f64 y i)
(*.f64 i y)
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (fma.f64 (log.f64 y) x (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a))) (+.f64 t z)))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)
(+.f64 (fma.f64 (log.f64 y) x (fma.f64 i y (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a))) (+.f64 t z))
(/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) z)
(+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)
(fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
(fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))
y
i
(fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
(fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))
(log.f64 y)
x
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
t
a
z
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
(fma.f64 i y #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (log.f64 y) x (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) z) a))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (log.f64 y) x (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) z) a)))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(fma.f64 (log.f64 y) x (+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) z) a))
(+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+.f64 (+.f64 (/.f64 a x) (+.f64 (/.f64 t x) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (/.f64 z x)))) (log.f64 y))
(+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x))
(+.f64 (/.f64 a x) (+.f64 (/.f64 t x) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (/.f64 z x))))
(+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x))
(+.f64 (/.f64 t x) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (/.f64 z x)))
(fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (/.f64 z x))
(/.f64 (log.f64 c) x)
(log.f64 c)
c
x
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(/.f64 z x)
z
(/.f64 t x)
t
(/.f64 a x)
a
(log.f64 y)
y
(*.f64 y i)
(*.f64 i y)
i

localize630.0ms (4.7%)

Memory
-40.0MiB live, 312.2MiB allocated
Localize:

Found 18 expressions of interest:

NewMetricScoreProgram
accuracy0.296875
(/.f64 (log.f64 c) x)
accuracy1.5702959856333614
(fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))
accuracy2.453114679151029
(+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x))
accuracy18.53607543379259
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
accuracy0.07421875
(fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
accuracy0.140625
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
accuracy3.1891038189830785
(/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
accuracy13.505404141311258
(fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)
accuracy0
(*.f64 y i)
accuracy0
(log.f64 y)
accuracy0.25390625
(*.f64 (log.f64 y) x)
accuracy51.69722981425274
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))
accuracy0
(*.f64 y i)
accuracy48.359879640749966
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
accuracy0
(log.f64 c)
accuracy0.00390625
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))
accuracy0.07421875
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))
accuracy9.05916299124386
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
Samples
105.0ms255×0valid
1.0ms1×1valid
Compiler

Compiled 454 to 44 computations (90.3% saved)

Precisions
Click to see histograms. Total time spent on operations: 49.0ms
ival-add: 19.0ms (39.2% of total)
ival-mult: 11.0ms (22.7% of total)
ival-div: 9.0ms (18.5% of total)
ival-log: 7.0ms (14.4% of total)
ival-sub: 1.0ms (2.1% 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)

series209.0ms (1.5%)

Memory
-16.2MiB live, 255.0MiB allocated
Counts
24 → 1 572
Calls
Call 1
Inputs
#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())
#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())
#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())
#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())
#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())
#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())
#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())
#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())
#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())
#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())
#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())
#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())
#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())
#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())
#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())
#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())
#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())
#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())
#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())
Outputs
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* (log c) (- b 1/2))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* (log c) (- b 1/2))))) (taylor 0 i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) (patch (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) #<representation binary64>) () ())) ())
#s(alt a (taylor 0 t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt t (taylor 0 a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (* i y))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b))))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b))))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b))))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (* (log c) (- b 1/2))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))) (taylor inf y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))) (taylor inf y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))) (taylor inf y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y))))) (taylor -inf y) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (* (log c) (- b 1/2))) (taylor 0 i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))) (taylor inf i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))) (taylor inf i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))) (taylor inf i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i))))) (taylor -inf i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i))))) (taylor -inf i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i))))) (taylor -inf i) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ (* i y) (* (log c) (- b 1/2))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) (taylor inf z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) (taylor inf z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) (taylor inf z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* (log c) (- b 1/2))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (log y) (taylor 0 y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (log y) (taylor 0 y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (log y) (taylor 0 y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (log y) (taylor 0 y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 y))) (taylor inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 y))) (taylor inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 y))) (taylor inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 y))) (taylor inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 y)))) (taylor -inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 y)))) (taylor -inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 y)))) (taylor -inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 y)))) (taylor -inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z) (taylor 0 y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) z) (taylor inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z))))))) (taylor inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z))))))) (taylor inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z))))))) (taylor inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) z) (taylor -inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -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))))) (taylor -inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -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))))) (taylor -inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -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))))) (taylor -inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z) (taylor 0 i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) z) (taylor inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z))))))) (taylor inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z))))))) (taylor inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z))))))) (taylor inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) z) (taylor -inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i))))) (taylor -inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i))))) (taylor -inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i))))) (taylor -inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z) (taylor 0 x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) z) (taylor inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))) (taylor inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))) (taylor inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))) (taylor inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) z) (taylor -inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x))))) (taylor -inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x))))) (taylor -inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x))))) (taylor -inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) z) (taylor 0 b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z)))))) (taylor 0 b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z)))))) (taylor 0 b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z)))))) (taylor 0 b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) z) (taylor inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* 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)))))))) (taylor inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* 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)))))))) (taylor inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* 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)))))))) (taylor inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) z) (taylor -inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b))))) (taylor -inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b))))) (taylor -inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b))))) (taylor -inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z) (taylor inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z) (taylor inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z) (taylor inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z) (taylor inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z) (taylor -inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z) (taylor -inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z) (taylor -inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z) (taylor -inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z) (taylor 0 t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ t z) (taylor inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z))))))) (taylor inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z))))))) (taylor inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z))))))) (taylor inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ t z) (taylor -inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z)))) (taylor -inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z)))) (taylor -inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z)))) (taylor -inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z) (taylor 0 a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ a z) (taylor inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ a z) (taylor -inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z)))) (taylor -inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z)))) (taylor -inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z)))) (taylor -inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor -inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor -inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor -inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor -inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) (patch (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) (taylor inf c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) (taylor inf c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) (taylor inf c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) (taylor inf c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))) (taylor -inf c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))) (taylor -inf c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))) (taylor -inf c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))) (taylor -inf c) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* (log c) (- b 1/2))))) (taylor 0 x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (+ (* -1 (/ a x)) (+ (* -1 (/ t x)) (+ (* -1 (/ z x)) (* -1 (/ (* (log c) (- b 1/2)) x)))))))) (taylor -inf x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (+ (* -1 (/ a x)) (+ (* -1 (/ t x)) (+ (* -1 (/ z x)) (* -1 (/ (* (log c) (- b 1/2)) x)))))))) (taylor -inf x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (+ (* -1 (/ a x)) (+ (* -1 (/ t x)) (+ (* -1 (/ z x)) (* -1 (/ (* (log c) (- b 1/2)) x)))))))) (taylor -inf x) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) (taylor 0 b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ (* b (log c)) (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))) (taylor 0 b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ (* b (log c)) (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))) (taylor 0 b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ (* b (log c)) (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))) (taylor 0 b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b))) (taylor inf b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b))) (taylor inf b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b))) (taylor inf b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b))))) (taylor -inf b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b))))) (taylor -inf b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b))))) (taylor -inf b) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ z (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z))) (taylor inf z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z))) (taylor inf z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z))) (taylor inf z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)) 1))) (taylor -inf z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)) 1))) (taylor -inf z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)) 1))) (taylor -inf z) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ t (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ t (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ t (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t))) (taylor inf t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t))) (taylor inf t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t))) (taylor inf t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)) 1))) (taylor -inf t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)) 1))) (taylor -inf t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)) 1))) (taylor -inf t) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ a (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ a (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ a (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a))) (taylor inf a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a))) (taylor inf a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a))) (taylor inf a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)) 1))) (taylor -inf a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)) 1))) (taylor -inf a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)) 1))) (taylor -inf a) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor 0 y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))) (taylor -inf y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))) (taylor -inf y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))) (taylor -inf y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))) (taylor -inf y) (#s(alt (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) (patch (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* (log c) (- b 1/2))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) (taylor inf c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) (taylor inf c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) (taylor inf c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) (taylor inf c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) x) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) x) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) x) (taylor 0 x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (log y) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor inf x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (log y) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x))) (taylor -inf x) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x)))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x)))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x)))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) x) (taylor inf b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (+ (/ (log c) x) (/ (log y) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (+ (/ (log c) x) (/ (log y) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (+ (/ (log c) x) (/ (log y) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) x) (taylor -inf b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ z x) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (/ (* (log c) (- b 1/2)) (* x z))))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (/ (* (log c) (- b 1/2)) (* x z))))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (/ (* (log c) (- b 1/2)) (* x z))))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ z x) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) z)) (/ 1 x)))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) z)) (/ 1 x)))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) z)) (/ 1 x)))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ t x) (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (+ (/ (log y) t) (/ (* (log c) (- b 1/2)) (* t x))))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (+ (/ (log y) t) (/ (* (log c) (- b 1/2)) (* t x))))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (+ (/ (log y) t) (/ (* (log c) (- b 1/2)) (* t x))))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ t x) (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) t)) (/ 1 x)))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) t)) (/ 1 x)))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) t)) (/ 1 x)))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ a x) (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ a x) (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) a)) (/ 1 x)))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) a)) (/ 1 x)))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) a)) (/ 1 x)))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) (taylor inf y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) (patch (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (log c) (taylor 0 c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (log c) (taylor 0 c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (log c) (taylor 0 c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (log c) (taylor 0 c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 c))) (taylor inf c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 c))) (taylor inf c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 c))) (taylor inf c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 c))) (taylor inf c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 c)))) (taylor -inf c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 c)))) (taylor -inf c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 c)))) (taylor -inf c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 c)))) (taylor -inf c) (#s(alt (log.f64 c) (patch (log.f64 c) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1/2 (log c))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b)))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b)))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b)))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 (* (log (/ 1 c)) (- b 1/2)))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 (* (log (/ 1 c)) (- b 1/2)))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 (* (log (/ 1 c)) (- b 1/2)))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 (* (log (/ 1 c)) (- b 1/2)))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* (log c) (- b 1/2)) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ (* (log c) (- b 1/2)) t))) (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ (* (log c) (- b 1/2)) t))) (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ (* (log c) (- b 1/2)) t))) (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))) (taylor inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))) (taylor inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))) (taylor inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))) (taylor inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))) (taylor -inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))) (taylor -inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))) (taylor -inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))) (taylor -inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) (taylor inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) (taylor inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) (taylor inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x))))) (taylor -inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x))))) (taylor -inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x))))) (taylor -inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (* x (log y)))) (taylor 0 b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))) (taylor 0 b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))) (taylor 0 b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))) (taylor 0 b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b))))) (taylor inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b))))) (taylor inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b))))) (taylor inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b))))) (taylor -inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b))))) (taylor -inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b))))) (taylor -inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))) (taylor inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))) (taylor inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))) (taylor inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))) (taylor inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ (* x (log y)) (* (log c) (- b 1/2))) (taylor 0 t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))) (taylor inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))) (taylor inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))) (taylor inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) (taylor inf c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) (taylor inf c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) (taylor inf c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) (taylor inf c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))) (taylor -inf c) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x) (taylor 0 x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x) (taylor 0 x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x) (taylor 0 x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x) (taylor 0 x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x) (taylor inf x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x) (taylor inf x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x) (taylor inf x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x) (taylor inf x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x)) (taylor -inf x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x)) (taylor -inf x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x)) (taylor -inf x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x)) (taylor -inf x) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) x) (taylor inf b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (/ (log c) x)))))) (taylor inf b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (/ (log c) x)))))) (taylor inf b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (/ (log c) x)))))) (taylor inf b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) x) (taylor -inf b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ z x) (taylor inf z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ z x) (taylor -inf z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))) z)) (/ 1 x)))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))) z)) (/ 1 x)))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))) z)) (/ 1 x)))) (taylor -inf z) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ t x) (taylor inf t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (/ (* (log c) (- b 1/2)) (* t x)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (/ (* (log c) (- b 1/2)) (* t x)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (/ (* (log c) (- b 1/2)) (* t x)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ t x) (taylor -inf t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) t)) (/ 1 x)))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) t)) (/ 1 x)))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) t)) (/ 1 x)))) (taylor -inf t) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) (taylor 0 a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ a x) (taylor inf a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (/ a x) (taylor -inf a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) a)) (/ 1 x)))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) a)) (/ 1 x)))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) a)) (/ 1 x)))) (taylor -inf a) (#s(alt (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (patch (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z x) (/ (* (log c) (- b 1/2)) x)) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z x) (/ (* (log c) (- b 1/2)) x)) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z x) (/ (* (log c) (- b 1/2)) x)) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z x) (/ (* (log c) (- b 1/2)) x)) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x)) (taylor inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x)) (taylor inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x)) (taylor inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x)) (taylor inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* (log c) (- b 1/2))) x) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* (log c) (- b 1/2))) x) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* (log c) (- b 1/2))) x) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* (log c) (- b 1/2))) x) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* (log c) (- b 1/2))) x) (taylor inf x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* (log c) (- b 1/2))) x) (taylor inf x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* (log c) (- b 1/2))) x) (taylor inf x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* (log c) (- b 1/2))) x) (taylor inf x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x)) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x)) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x)) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x)) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) x)) (/ z x)) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) x)) (+ (/ z x) (/ (* b (log c)) x))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) x)) (+ (/ z x) (/ (* b (log c)) x))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) x)) (+ (/ z x) (/ (* b (log c)) x))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) x) (taylor inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ z (* b x)) (/ (log c) x)))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ z (* b x)) (/ (log c) x)))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ z (* b x)) (/ (log c) x)))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) x) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (/ z x)) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (/ z x)) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (/ z x)) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (* (log c) (- b 1/2)) x) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z x) (/ (* (log c) (- b 1/2)) x)) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z x) (/ (* (log c) (- b 1/2)) x)) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z x) (/ (* (log c) (- b 1/2)) x)) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ z x) (taylor inf z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 x) (/ (* (log c) (- b 1/2)) (* x z)))) (taylor inf z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 x) (/ (* (log c) (- b 1/2)) (* x z)))) (taylor inf z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 x) (/ (* (log c) (- b 1/2)) (* x z)))) (taylor inf z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ z x) (taylor -inf z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* (log c) (- b 1/2)) (* x z))) (/ 1 x)))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* (log c) (- b 1/2)) (* x z))) (/ 1 x)))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* (log c) (- b 1/2)) (* x z))) (/ 1 x)))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (patch (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor 0 c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor 0 c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor 0 c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor 0 c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 c)) x)) (taylor inf c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 c)) x)) (taylor inf c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 c)) x)) (taylor inf c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 c)) x)) (taylor inf c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 c)))) x) (taylor -inf c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 c)))) x) (taylor -inf c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 c)))) x) (taylor -inf c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 c)))) x) (taylor -inf c) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor 0 x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor 0 x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor 0 x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor 0 x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor inf x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor inf x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor inf x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor inf x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor -inf x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor -inf x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor -inf x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
#s(alt (/ (log c) x) (taylor -inf x) (#s(alt (/.f64 (log.f64 c) x) (patch (/.f64 (log.f64 c) x) #<representation binary64>) () ())) ())
Calls

393 calls:

TimeVariablePointExpression
13.0ms
z
@0
(/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z)
10.0ms
i
@-inf
(* y i)
7.0ms
z
@inf
(/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z)
5.0ms
x
@0
(+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x))
3.0ms
z
@-inf
(+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y))

simplify330.0ms (2.4%)

Memory
8.3MiB live, 358.8MiB allocated
Algorithm
1×egg-herbie
Rules
6 624×lower-fma.f64
6 624×lower-fma.f32
5 894×lower-*.f64
5 894×lower-*.f32
4 740×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
083930460
1284330069
2750029779
0827927853
Stop Event
1×iter limit
1×node limit
Counts
1 572 → 1 496
Calls
Call 1
Inputs
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(* i y)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
a
(+ a t)
(+ a t)
(+ a t)
t
(* t (+ 1 (/ a t)))
(* t (+ 1 (/ a t)))
(* t (+ 1 (/ a t)))
t
(* -1 (* t (- (* -1 (/ a t)) 1)))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(* -1 (* t (- (* -1 (/ a t)) 1)))
t
(+ a t)
(+ a t)
(+ a t)
a
(* a (+ 1 (/ t a)))
(* a (+ 1 (/ t a)))
(* a (+ 1 (/ t a)))
a
(* -1 (* a (- (* -1 (/ t a)) 1)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(+ z (+ (* -1/2 (log c)) (* i y)))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (* (log c) (- b 1/2)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(* i y)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(+ z (* (log c) (- b 1/2)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(* i y)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(+ (* i y) (* (log c) (- b 1/2)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
z
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
z
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(log y)
(log y)
(log y)
(log y)
(* -1 (log (/ 1 y)))
(* -1 (log (/ 1 y)))
(* -1 (log (/ 1 y)))
(* -1 (log (/ 1 y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(+ (log -1) (* -1 (log (/ -1 y))))
(+ (log -1) (* -1 (log (/ -1 y))))
(+ (log -1) (* -1 (log (/ -1 y))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(/ (* i y) z)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(/ (* i y) z)
(* -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)))))
(* -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)))))
(* -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)))))
(/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(/ (* i y) z)
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(/ (* i y) z)
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(/ (* x (log y)) z)
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(/ (* x (log y)) z)
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) z)
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(/ (* b (log c)) z)
(* 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))))))))
(* 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))))))))
(* 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))))))))
(/ (* b (log c)) z)
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(/ t z)
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(/ t z)
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(/ a z)
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(/ a z)
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))
(* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))
(* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))
(* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (+ (* -1 (/ a x)) (+ (* -1 (/ t x)) (+ (* -1 (/ z x)) (* -1 (/ (* (log c) (- b 1/2)) x))))))))
(* -1 (* x (+ (* -1 (log y)) (+ (* -1 (/ a x)) (+ (* -1 (/ t x)) (+ (* -1 (/ z x)) (* -1 (/ (* (log c) (- b 1/2)) x))))))))
(* -1 (* x (+ (* -1 (log y)) (+ (* -1 (/ a x)) (+ (* -1 (/ t x)) (+ (* -1 (/ z x)) (* -1 (/ (* (log c) (- b 1/2)) x))))))))
(* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))
(+ (* b (log c)) (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))))
(+ (* b (log c)) (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))))
(+ (* b (log c)) (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))))
(* b (log c))
(* b (+ (log c) (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))
(* b (+ (log c) (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))
(* b (+ (log c) (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))))
(+ z (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))))
(+ z (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))))
(+ z (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))))
z
(* z (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)))
(* z (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)))
(* z (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)))
z
(* -1 (* z (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)) 1)))
(* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ t (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(+ t (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(+ t (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
t
(* t (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)))
(* t (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)))
(* t (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)))
t
(* -1 (* t (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)) 1)))
(* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ a (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(+ a (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(+ a (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
a
(* a (+ 1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)))
(* a (+ 1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)))
(* a (+ 1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)))
a
(* -1 (* a (- (* -1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)) 1)))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))
(+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))
(+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))
(+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) x)
(/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) x)
(/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) x)
(log y)
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(log y)
(+ (log y) (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x)))
(+ (log y) (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x)))
(+ (log y) (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x)))
(+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))
(+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x))))))
(+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x))))))
(+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x))))))
(/ (* b (log c)) x)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (+ (/ (log c) x) (/ (log y) b)))))))
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (+ (/ (log c) x) (/ (log y) b)))))))
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (+ (/ (log c) x) (/ (log y) b)))))))
(/ (* b (log c)) x)
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) b)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(/ z x)
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (/ (* (log c) (- b 1/2)) (* x z)))))))
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (/ (* (log c) (- b 1/2)) (* x z)))))))
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (/ (* (log c) (- b 1/2)) (* x z)))))))
(/ z x)
(* -1 (* z (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) z)) (/ 1 x))))
(* -1 (* z (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) z)) (/ 1 x))))
(* -1 (* z (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) z)) (/ 1 x))))
(+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(/ t x)
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (+ (/ (log y) t) (/ (* (log c) (- b 1/2)) (* t x)))))))
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (+ (/ (log y) t) (/ (* (log c) (- b 1/2)) (* t x)))))))
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (+ (/ (log y) t) (/ (* (log c) (- b 1/2)) (* t x)))))))
(/ t x)
(* -1 (* t (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) t)) (/ 1 x))))
(* -1 (* t (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) t)) (/ 1 x))))
(* -1 (* t (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) t)) (/ 1 x))))
(+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(/ a x)
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))))
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))))
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))))
(/ a x)
(* -1 (* a (- (* -1 (/ (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) a)) (/ 1 x))))
(* -1 (* a (- (* -1 (/ (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) a)) (/ 1 x))))
(* -1 (* a (- (* -1 (/ (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) a)) (/ 1 x))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(log c)
(log c)
(log c)
(log c)
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(* -1 (log (/ 1 c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ (log -1) (* -1 (log (/ -1 c))))
(+ t (* -1/2 (log c)))
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(+ t (* (log c) (- b 1/2)))
(+ t (* (log c) (- b 1/2)))
(+ t (* (log c) (- b 1/2)))
(+ t (* (log c) (- b 1/2)))
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(* (log c) (- b 1/2))
(+ t (* (log c) (- b 1/2)))
(+ t (* (log c) (- b 1/2)))
(+ t (* (log c) (- b 1/2)))
t
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
t
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+ t (* (log c) (- b 1/2)))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(* x (log y))
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(+ t (+ (* -1/2 (log c)) (* x (log y))))
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
t
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
t
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x))
(* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x))
(* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x))
(* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x))
(+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))
(+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x)))))
(+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x)))))
(+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x)))))
(/ (* b (log c)) x)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (/ (log c) x))))))
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (/ (log c) x))))))
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (/ (log c) x))))))
(/ (* b (log c)) x)
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) b)))))
(+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(/ z x)
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))
(/ z x)
(* -1 (* z (- (* -1 (/ (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))) z)) (/ 1 x))))
(* -1 (* z (- (* -1 (/ (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))) z)) (/ 1 x))))
(* -1 (* z (- (* -1 (/ (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))) z)) (/ 1 x))))
(+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(/ t x)
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (/ (* (log c) (- b 1/2)) (* t x))))))
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (/ (* (log c) (- b 1/2)) (* t x))))))
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (/ (* (log c) (- b 1/2)) (* t x))))))
(/ t x)
(* -1 (* t (- (* -1 (/ (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) t)) (/ 1 x))))
(* -1 (* t (- (* -1 (/ (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) t)) (/ 1 x))))
(* -1 (* t (- (* -1 (/ (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) t)) (/ 1 x))))
(+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(/ a x)
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))
(/ a x)
(* -1 (* a (- (* -1 (/ (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) a)) (/ 1 x))))
(* -1 (* a (- (* -1 (/ (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) a)) (/ 1 x))))
(* -1 (* a (- (* -1 (/ (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) a)) (/ 1 x))))
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x))
(+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))
(+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))
(+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))
(+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))
(/ (+ z (* (log c) (- b 1/2))) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x))
(* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x))
(* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x))
(* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x))
(+ (* -1/2 (/ (log c) x)) (/ z x))
(+ (* -1/2 (/ (log c) x)) (+ (/ z x) (/ (* b (log c)) x)))
(+ (* -1/2 (/ (log c) x)) (+ (/ z x) (/ (* b (log c)) x)))
(+ (* -1/2 (/ (log c) x)) (+ (/ z x) (/ (* b (log c)) x)))
(/ (* b (log c)) x)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ z (* b x)) (/ (log c) x))))
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ z (* b x)) (/ (log c) x))))
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ z (* b x)) (/ (log c) x))))
(/ (* b (log c)) x)
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (/ z x)) b)))))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (/ z x)) b)))))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (/ z x)) b)))))
(/ (* (log c) (- b 1/2)) x)
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(/ z x)
(* z (+ (/ 1 x) (/ (* (log c) (- b 1/2)) (* x z))))
(* z (+ (/ 1 x) (/ (* (log c) (- b 1/2)) (* x z))))
(* z (+ (/ 1 x) (/ (* (log c) (- b 1/2)) (* x z))))
(/ z x)
(* -1 (* z (- (* -1 (/ (* (log c) (- b 1/2)) (* x z))) (/ 1 x))))
(* -1 (* z (- (* -1 (/ (* (log c) (- b 1/2)) (* x z))) (/ 1 x))))
(* -1 (* z (- (* -1 (/ (* (log c) (- b 1/2)) (* x z))) (/ 1 x))))
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
(* -1 (/ (log (/ 1 c)) x))
(* -1 (/ (log (/ 1 c)) x))
(* -1 (/ (log (/ 1 c)) x))
(* -1 (/ (log (/ 1 c)) x))
(/ (+ (log -1) (* -1 (log (/ -1 c)))) x)
(/ (+ (log -1) (* -1 (log (/ -1 c)))) x)
(/ (+ (log -1) (* -1 (log (/ -1 c)))) x)
(/ (+ (log -1) (* -1 (log (/ -1 c)))) x)
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
(/ (log c) x)
Outputs
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 y i)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 y i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 y i) t)) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 y i) t)) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 y i) t)) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 y i) a)) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 y i) a)) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 y i) a)) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y)))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 y i)) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 y i)) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 y i)) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 y i)) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 y i)) z))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 y i)) z))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 y i)) z))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 y i)) z))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(* i y)
(*.f64 y i)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y))) y)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y))) y)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y))) y)
(* i y)
(*.f64 y i)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) y) i)) (neg.f64 y))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(* i y)
(*.f64 y i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 y i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) i) y)) (neg.f64 i))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 z)) z (neg.f64 z)))
a
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
t
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
t
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (neg.f64 a) t) #s(literal 1 binary64)))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (neg.f64 a) t) #s(literal 1 binary64)))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (neg.f64 a) t) #s(literal 1 binary64)))
t
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
a
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
a
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
(+ z (+ (* -1/2 (log c)) (* i y)))
(+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 y i)) z)
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 (/.f64 y b) i (/.f64 z b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 (/.f64 y b) i (/.f64 z b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 (/.f64 y b) i (/.f64 z b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 y i)) z) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 y i)) z) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 y i)) z) (neg.f64 b)) (log.f64 c)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 y i)) z)
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 y i)) z)
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 y i)) z)
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 y i)) z)
(+ z (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(* i y)
(*.f64 y i)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) i) y)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) i) y)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) i) y)
(* i y)
(*.f64 y i)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) y) i)) (neg.f64 y))
(+ z (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(* i y)
(*.f64 y i)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c) (/.f64 z i)) y) i)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c) (/.f64 z i)) y) i)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c) (/.f64 z i)) y) i)
(* i y)
(*.f64 y i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) i) y)) (neg.f64 i))
(+ (* i y) (* (log c) (- b 1/2)))
(fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))
z
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) z z)
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) z z)
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 y i)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 y i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(* i y)
(*.f64 y i)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 y i)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 y i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a)
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a)
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a)
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a)
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t)) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t)) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t)) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) b) x (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) b) x (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) b) x (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t 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)) (*.f64 (log.f64 y) x))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t 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)) (*.f64 (log.f64 y) x))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t 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)) (*.f64 (log.f64 y) x))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t 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)) (*.f64 (log.f64 y) x))) a)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(log y)
(log.f64 y)
(log y)
(log.f64 y)
(log y)
(log.f64 y)
(log y)
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 y i)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 y i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 y i)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 y i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(/ (* i y) z)
(/.f64 (*.f64 y i) z)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 y) x) (*.f64 y z)) (/.f64 a (*.f64 y z))) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y z)) (log.f64 c) (/.f64 t (*.f64 y z))) (/.f64 i z))) y)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 y) x) (*.f64 y z)) (/.f64 a (*.f64 y z))) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y z)) (log.f64 c) (/.f64 t (*.f64 y z))) (/.f64 i z))) y)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 y) x) (*.f64 y z)) (/.f64 a (*.f64 y z))) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y z)) (log.f64 c) (/.f64 t (*.f64 y z))) (/.f64 i z))) y)
(/ (* i y) z)
(/.f64 (*.f64 y i) z)
(* -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)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) (/.f64 x z))) (/.f64 t z)) (/.f64 a z)) (neg.f64 y)) (/.f64 i z)) (neg.f64 y))
(* -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)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) (/.f64 x z))) (/.f64 t z)) (/.f64 a z)) (neg.f64 y)) (/.f64 i z)) (neg.f64 y))
(* -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)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) (/.f64 x z))) (/.f64 t z)) (/.f64 a z)) (neg.f64 y)) (/.f64 i z)) (neg.f64 y))
(/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(/ (* i y) z)
(/.f64 (*.f64 y i) z)
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) (/.f64 x (*.f64 i z)) (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 i z))) (/.f64 y z)) (/.f64 t (*.f64 i z))) (/.f64 a (*.f64 i z))) i)
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) (/.f64 x (*.f64 i z)) (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 i z))) (/.f64 y z)) (/.f64 t (*.f64 i z))) (/.f64 a (*.f64 i z))) i)
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 y) (/.f64 x (*.f64 i z)) (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 i z))) (/.f64 y z)) (/.f64 t (*.f64 i z))) (/.f64 a (*.f64 i z))) i)
(/ (* i y) z)
(/.f64 (*.f64 y i) z)
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z)) (neg.f64 i)) (/.f64 y z)) (neg.f64 i))
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z)) (neg.f64 i)) (/.f64 y z)) (neg.f64 i))
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z)) (neg.f64 i)) (/.f64 y z)) (neg.f64 i))
(/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(/ (* x (log y)) z)
(/.f64 (*.f64 (log.f64 y) x) z)
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 x z)) i (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 x z))) (/.f64 (log.f64 y) z)) (/.f64 t (*.f64 x z))) (/.f64 a (*.f64 x z))) x)
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 x z)) i (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 x z))) (/.f64 (log.f64 y) z)) (/.f64 t (*.f64 x z))) (/.f64 a (*.f64 x z))) x)
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 x z)) i (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 x z))) (/.f64 (log.f64 y) z)) (/.f64 t (*.f64 x z))) (/.f64 a (*.f64 x z))) x)
(/ (* x (log y)) z)
(/.f64 (*.f64 (log.f64 y) x) z)
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) (/.f64 t z)) (/.f64 a z)) (neg.f64 x)) (/.f64 (log.f64 y) z)))
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) (/.f64 t z)) (/.f64 a z)) (neg.f64 x)) (/.f64 (log.f64 y) z)))
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) (/.f64 t z)) (/.f64 a z)) (neg.f64 x)) (/.f64 (log.f64 y) z)))
(/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) z)
(/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) t) a) z)
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) z) b (fma.f64 (/.f64 (log.f64 y) z) x (/.f64 (*.f64 y i) z))) (/.f64 t z)) (/.f64 a z)))
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) z) b (fma.f64 (/.f64 (log.f64 y) z) x (/.f64 (*.f64 y i) z))) (/.f64 t z)) (/.f64 a z)))
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) z) b (fma.f64 (/.f64 (log.f64 y) z) x (/.f64 (*.f64 y i) z))) (/.f64 t z)) (/.f64 a z)))
(/ (* b (log c)) z)
(*.f64 (/.f64 (log.f64 c) z) b)
(* 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))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b z)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 b z)) i (*.f64 (log.f64 y) (/.f64 x (*.f64 b z)))) (/.f64 (log.f64 c) z)) (/.f64 t (*.f64 b z))) (/.f64 a (*.f64 b z)))) b)
(* 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))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b z)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 b z)) i (*.f64 (log.f64 y) (/.f64 x (*.f64 b z)))) (/.f64 (log.f64 c) z)) (/.f64 t (*.f64 b z))) (/.f64 a (*.f64 b z)))) b)
(* 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))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b z)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 b z)) i (*.f64 (log.f64 y) (/.f64 x (*.f64 b z)))) (/.f64 (log.f64 c) z)) (/.f64 t (*.f64 b z))) (/.f64 a (*.f64 b z)))) b)
(/ (* b (log c)) z)
(*.f64 (/.f64 (log.f64 c) z) b)
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) z) x (/.f64 (*.f64 y i) z)) (/.f64 t z)) (/.f64 a z))) (neg.f64 b)) (/.f64 (log.f64 c) z)))
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) z) x (/.f64 (*.f64 y i) z)) (/.f64 t z)) (/.f64 a z))) (neg.f64 b)) (/.f64 (log.f64 c) z)))
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) z) x (/.f64 (*.f64 y i) z)) (/.f64 t z)) (/.f64 a z))) (neg.f64 b)) (/.f64 (log.f64 c) z)))
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a) z)
(/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(/.f64 (+.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) a) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(/ t z)
(/.f64 t z)
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 z t)) i (fma.f64 (log.f64 y) (/.f64 x (*.f64 z t)) (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 z t)))) (/.f64 a (*.f64 z t))) t (/.f64 t z))
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 z t)) i (fma.f64 (log.f64 y) (/.f64 x (*.f64 z t)) (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 z t)))) (/.f64 a (*.f64 z t))) t (/.f64 t z))
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 z t)) i (fma.f64 (log.f64 y) (/.f64 x (*.f64 z t)) (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 z t)))) (/.f64 a (*.f64 z t))) t (/.f64 t z))
(/ t z)
(/.f64 t z)
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 a z)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) z)))
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 a z)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) z)))
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 a z)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) z)))
(/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 (log.f64 y) x (*.f64 y i))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z))
(/ a z)
(/.f64 a z)
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 z a)) i (fma.f64 (log.f64 y) (/.f64 x (*.f64 z a)) (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 z a)))) (/.f64 t (*.f64 z a))) a (/.f64 a z))
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 z a)) i (fma.f64 (log.f64 y) (/.f64 x (*.f64 z a)) (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 z a)))) (/.f64 t (*.f64 z a))) a (/.f64 a z))
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y (*.f64 z a)) i (fma.f64 (log.f64 y) (/.f64 x (*.f64 z a)) (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 z a)))) (/.f64 t (*.f64 z a))) a (/.f64 a z))
(/ a z)
(/.f64 a z)
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (neg.f64 a)) (/.f64 #s(literal 1 binary64) z)))
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (neg.f64 a)) (/.f64 #s(literal 1 binary64) z)))
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (neg.f64 a)) (/.f64 #s(literal 1 binary64) z)))
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) z)
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 y i)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) (neg.f64 y)) i) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) (neg.f64 y)) i) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) (neg.f64 y)) i) (neg.f64 y))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 t i))) i)
(* i y)
(*.f64 y i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) t) a)
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.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 y i))) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.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 y i))) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.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 y i))) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) t) a)
(+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
t
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) a) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 (log.f64 y) x (*.f64 y i)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
a
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 (log.f64 y) x (*.f64 y i))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 (log.f64 y) x (*.f64 y i))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 (log.f64 y) x (*.f64 y i))) (neg.f64 a)) a (neg.f64 a)))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) x)
(* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) x)
(* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) x)
(* x (+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (+ (* -1 (/ a x)) (+ (* -1 (/ t x)) (+ (* -1 (/ z x)) (* -1 (/ (* (log c) (- b 1/2)) x))))))))
(*.f64 (neg.f64 x) (-.f64 (-.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (+ (* -1 (/ a x)) (+ (* -1 (/ t x)) (+ (* -1 (/ z x)) (* -1 (/ (* (log c) (- b 1/2)) x))))))))
(*.f64 (neg.f64 x) (-.f64 (-.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (+ (* -1 (/ a x)) (+ (* -1 (/ t x)) (+ (* -1 (/ z x)) (* -1 (/ (* (log c) (- b 1/2)) x))))))))
(*.f64 (neg.f64 x) (-.f64 (-.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)))
(* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) x)
(+ (* b (log c)) (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) x (*.f64 b (log.f64 c)))
(+ (* b (log c)) (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) x (*.f64 b (log.f64 c)))
(+ (* b (log c)) (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) x (*.f64 b (log.f64 c)))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))
(*.f64 (fma.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) (/.f64 x b) (log.f64 c)) b)
(* b (+ (log c) (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))
(*.f64 (fma.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) (/.f64 x b) (log.f64 c)) b)
(* b (+ (log c) (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))
(*.f64 (fma.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) (/.f64 x b) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))))
(*.f64 (neg.f64 b) (neg.f64 (fma.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) (/.f64 x b) (log.f64 c))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))))
(*.f64 (neg.f64 b) (neg.f64 (fma.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) (/.f64 x b) (log.f64 c))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (* x (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))) b)))))
(*.f64 (neg.f64 b) (neg.f64 (fma.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) (/.f64 x b) (log.f64 c))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))))
(*.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) x)
(+ z (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))))
(fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) x z)
(+ z (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))))
(fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) x z)
(+ z (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))))
(fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) x z)
z
(* z (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)))
(*.f64 (fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) (/.f64 x z) #s(literal 1 binary64)) z)
(* z (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)))
(*.f64 (fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) (/.f64 x z) #s(literal 1 binary64)) z)
(* z (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)))
(*.f64 (fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) (/.f64 x z) #s(literal 1 binary64)) z)
z
(* -1 (* z (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)) 1)))
(*.f64 (neg.f64 z) (fma.f64 x (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) (neg.f64 z)) #s(literal -1 binary64)))
(* -1 (* z (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)) 1)))
(*.f64 (neg.f64 z) (fma.f64 x (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) (neg.f64 z)) #s(literal -1 binary64)))
(* -1 (* z (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))) z)) 1)))
(*.f64 (neg.f64 z) (fma.f64 x (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) (neg.f64 z)) #s(literal -1 binary64)))
(* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(*.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) x)
(+ t (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) x t)
(+ t (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) x t)
(+ t (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) x t)
t
(* t (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)))
(*.f64 (fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) (/.f64 x t) #s(literal 1 binary64)) t)
(* t (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)))
(*.f64 (fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) (/.f64 x t) #s(literal 1 binary64)) t)
(* t (+ 1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)))
(*.f64 (fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) (/.f64 x t) #s(literal 1 binary64)) t)
t
(* -1 (* t (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)) 1)))
(*.f64 (neg.f64 t) (fma.f64 x (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) (neg.f64 t)) #s(literal -1 binary64)))
(* -1 (* t (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)) 1)))
(*.f64 (neg.f64 t) (fma.f64 x (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) (neg.f64 t)) #s(literal -1 binary64)))
(* -1 (* t (- (* -1 (/ (* x (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) t)) 1)))
(*.f64 (neg.f64 t) (fma.f64 x (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) (neg.f64 t)) #s(literal -1 binary64)))
(* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(*.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) x)
(+ a (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) x a)
(+ a (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) x a)
(+ a (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) x a)
a
(* a (+ 1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)))
(*.f64 (fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) (/.f64 x a) #s(literal 1 binary64)) a)
(* a (+ 1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)))
(*.f64 (fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) (/.f64 x a) #s(literal 1 binary64)) a)
(* a (+ 1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)))
(*.f64 (fma.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) (/.f64 x a) #s(literal 1 binary64)) a)
a
(* -1 (* a (- (* -1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)) 1)))
(*.f64 (neg.f64 a) (fma.f64 x (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) (neg.f64 a)) #s(literal -1 binary64)))
(* -1 (* a (- (* -1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)) 1)))
(*.f64 (neg.f64 a) (fma.f64 x (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) (neg.f64 a)) #s(literal -1 binary64)))
(* -1 (* a (- (* -1 (/ (* x (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))) a)) 1)))
(*.f64 (neg.f64 a) (fma.f64 x (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) (neg.f64 a)) #s(literal -1 binary64)))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))) x)
(* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))) x)
(* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))) x)
(* x (+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))) x)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y x) i (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 y i))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (log.f64 c) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 y i)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y z) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y t) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y a) i (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x (*.f64 y i))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 y b) i (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.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 y i))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 y i (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 (log.f64 y) x (*.f64 y i))))
(* i y)
(*.f64 y i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) i) x (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (log.f64 c))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 y i)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a)
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a)
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a)
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x))) a)
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t)) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t)) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t)) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) b) x (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) b) x (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) b) x (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x)))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t 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)) (*.f64 (log.f64 y) x))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t 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)) (*.f64 (log.f64 y) x))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t 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)) (*.f64 (log.f64 y) x))) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t 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)) (*.f64 (log.f64 y) x))) a)
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))
(+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y))
(+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))
(+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y))
(+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))
(+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y))
(+ (log y) (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))
(+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x)
(/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) x)
(/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) x)
(/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) x)
(/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) x)
(/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) x)
(/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 (log.f64 y) x))) x)
(log y)
(log.f64 y)
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(log y)
(log.f64 y)
(+ (log y) (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x)))
(-.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)))
(+ (log y) (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x)))
(-.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)))
(+ (log y) (* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x)))
(-.f64 (log.f64 y) (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)))
(+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))))
(+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y))
(+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x))))))
(+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) b (/.f64 z x)) (/.f64 t x)) (/.f64 a x))) (log.f64 y))
(+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x))))))
(+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) b (/.f64 z x)) (/.f64 t x)) (/.f64 a x))) (log.f64 y))
(+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x))))))
(+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) b (/.f64 z x)) (/.f64 t x)) (/.f64 a x))) (log.f64 y))
(/ (* b (log c)) x)
(*.f64 (/.f64 (log.f64 c) x) b)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (+ (/ (log c) x) (/ (log y) b)))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 x b)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (+.f64 (/.f64 (log.f64 y) b) (/.f64 (log.f64 c) x)) (/.f64 z (*.f64 x b))) (/.f64 t (*.f64 x b))) (/.f64 a (*.f64 x b)))) b)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (+ (/ (log c) x) (/ (log y) b)))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 x b)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (+.f64 (/.f64 (log.f64 y) b) (/.f64 (log.f64 c) x)) (/.f64 z (*.f64 x b))) (/.f64 t (*.f64 x b))) (/.f64 a (*.f64 x b)))) b)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (+ (/ (log c) x) (/ (log y) b)))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 x b)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (+.f64 (/.f64 (log.f64 y) b) (/.f64 (log.f64 c) x)) (/.f64 z (*.f64 x b))) (/.f64 t (*.f64 x b))) (/.f64 a (*.f64 x b)))) b)
(/ (* b (log c)) x)
(*.f64 (/.f64 (log.f64 c) x) b)
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) (neg.f64 b)) (/.f64 (log.f64 c) x)))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) (neg.f64 b)) (/.f64 (log.f64 c) x)))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (log y) (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (log.f64 y)) (neg.f64 b)) (/.f64 (log.f64 c) x)))
(+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(/ z x)
(/.f64 z x)
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (/ (* (log c) (- b 1/2)) (* x z)))))))
(fma.f64 (+.f64 (+.f64 (/.f64 a (*.f64 x z)) (/.f64 t (*.f64 x z))) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x z)) (log.f64 c) (/.f64 (log.f64 y) z))) z (/.f64 z x))
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (/ (* (log c) (- b 1/2)) (* x z)))))))
(fma.f64 (+.f64 (+.f64 (/.f64 a (*.f64 x z)) (/.f64 t (*.f64 x z))) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x z)) (log.f64 c) (/.f64 (log.f64 y) z))) z (/.f64 z x))
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (/ (* (log c) (- b 1/2)) (* x z)))))))
(fma.f64 (+.f64 (+.f64 (/.f64 a (*.f64 x z)) (/.f64 t (*.f64 x z))) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x z)) (log.f64 c) (/.f64 (log.f64 y) z))) z (/.f64 z x))
(/ z x)
(/.f64 z x)
(* -1 (* z (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) z)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) z)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) z)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (log.f64 y)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 z))
(+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(/ t x)
(/.f64 t x)
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (+ (/ (log y) t) (/ (* (log c) (- b 1/2)) (* t x)))))))
(fma.f64 (+.f64 (+.f64 (/.f64 a (*.f64 x t)) (/.f64 z (*.f64 x t))) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x t)) (log.f64 c) (/.f64 (log.f64 y) t))) t (/.f64 t x))
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (+ (/ (log y) t) (/ (* (log c) (- b 1/2)) (* t x)))))))
(fma.f64 (+.f64 (+.f64 (/.f64 a (*.f64 x t)) (/.f64 z (*.f64 x t))) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x t)) (log.f64 c) (/.f64 (log.f64 y) t))) t (/.f64 t x))
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (+ (/ (log y) t) (/ (* (log c) (- b 1/2)) (* t x)))))))
(fma.f64 (+.f64 (+.f64 (/.f64 a (*.f64 x t)) (/.f64 z (*.f64 x t))) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x t)) (log.f64 c) (/.f64 (log.f64 y) t))) t (/.f64 t x))
(/ t x)
(/.f64 t x)
(* -1 (* t (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) t)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) t)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (log y) (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) t)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 t))
(+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(/ a x)
(/.f64 a x)
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))))
(fma.f64 (+.f64 (+.f64 (/.f64 t (*.f64 x a)) (/.f64 z (*.f64 x a))) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (log.f64 c) (/.f64 (log.f64 y) a))) a (/.f64 a x))
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))))
(fma.f64 (+.f64 (+.f64 (/.f64 t (*.f64 x a)) (/.f64 z (*.f64 x a))) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (log.f64 c) (/.f64 (log.f64 y) a))) a (/.f64 a x))
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))))
(fma.f64 (+.f64 (+.f64 (/.f64 t (*.f64 x a)) (/.f64 z (*.f64 x a))) (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (log.f64 c) (/.f64 (log.f64 y) a))) a (/.f64 a x))
(/ a x)
(/.f64 a x)
(* -1 (* a (- (* -1 (/ (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) a)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) (neg.f64 a)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) a)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) (neg.f64 a)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ (log y) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))) a)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) (neg.f64 a)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 a))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (* -1 (log (/ 1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))
(+.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)))
(+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)))
(+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)))
(+ (log -1) (+ (* -1 (log (/ -1 y))) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(+.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x)))
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(log c)
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(* -1 (log (/ 1 c)))
(log.f64 c)
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ (log -1) (* -1 (log (/ -1 c))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c)))
(+ t (* -1/2 (log c)))
(fma.f64 #s(literal -1/2 binary64) (log.f64 c) t)
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (/.f64 t b)) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (/.f64 t b)) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (/.f64 t b)) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) t) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) t) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) t) (neg.f64 b)) (log.f64 c)))
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) t)
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) t)
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) t)
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) t)
(* (log c) (- b 1/2))
(*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c))
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
t
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
(fma.f64 (*.f64 t (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) t)
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
(fma.f64 (*.f64 t (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) t)
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
(fma.f64 (*.f64 t (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) t)
t
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(*.f64 (fma.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(*.f64 (fma.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(*.f64 (fma.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) #s(literal -1 binary64)) (neg.f64 t))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)) t)
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)) t)
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)) t)
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(*.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (log.f64 y)) x)
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(*.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (log.f64 y)) x)
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(*.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (neg.f64 x)) (log.f64 y)))
(+ t (+ (* -1/2 (log c)) (* x (log y))))
(+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) t)
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 y) b) x (/.f64 t b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 y) b) x (/.f64 t b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 y) b) x (/.f64 t b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) t) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) t) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) t) (neg.f64 b)) (log.f64 c)))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t)
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t)
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t)
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t)
(+ (* x (log y)) (* (log c) (- b 1/2)))
(fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
t
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
(fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t)) t t)
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
(fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t)) t t)
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
(fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 (log.f64 y) x) t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x)) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x)) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 (log.f64 y) x)) (neg.f64 t)) t (neg.f64 t)))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (+ (/ a x) (+ (/ t x) (/ z x))))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x)))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))
(+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))
(+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))
(+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))))
(+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x))
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x)
(/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)
(/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) x)
(* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x))
(neg.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)))
(* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x))
(neg.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)))
(* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x))
(neg.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)))
(* -1 (/ (+ (* -1 a) (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))))) x))
(neg.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)))
(+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x))))
(fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x)))
(+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x)))))
(fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) b (/.f64 z x)) (/.f64 t x)) (/.f64 a x)))
(+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x)))))
(fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) b (/.f64 z x)) (/.f64 t x)) (/.f64 a x)))
(+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* b (log c)) x)))))
(fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) b (/.f64 z x)) (/.f64 t x)) (/.f64 a x)))
(/ (* b (log c)) x)
(*.f64 (/.f64 (log.f64 c) x) b)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (/ (log c) x))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 x b)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (/.f64 z (*.f64 x b)) (/.f64 (log.f64 c) x)) (/.f64 t (*.f64 x b))) (/.f64 a (*.f64 x b)))) b)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (/ (log c) x))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 x b)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (/.f64 z (*.f64 x b)) (/.f64 (log.f64 c) x)) (/.f64 t (*.f64 x b))) (/.f64 a (*.f64 x b)))) b)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ a (* b x)) (+ (/ t (* b x)) (+ (/ z (* b x)) (/ (log c) x))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 x b)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (/.f64 z (*.f64 x b)) (/.f64 (log.f64 c) x)) (/.f64 t (*.f64 x b))) (/.f64 a (*.f64 x b)))) b)
(/ (* b (log c)) x)
(*.f64 (/.f64 (log.f64 c) x) b)
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (neg.f64 b)) (/.f64 (log.f64 c) x)))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (neg.f64 b)) (/.f64 (log.f64 c) x)))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (+ (/ a x) (+ (/ t x) (/ z x)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z x) (/.f64 t x)) (/.f64 a x))) (neg.f64 b)) (/.f64 (log.f64 c) x)))
(+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))
(+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(/ z x)
(/.f64 z x)
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x z)) (log.f64 c) (/.f64 t (*.f64 x z))) (/.f64 a (*.f64 x z))) z (/.f64 z x))
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x z)) (log.f64 c) (/.f64 t (*.f64 x z))) (/.f64 a (*.f64 x z))) z (/.f64 z x))
(* z (+ (/ 1 x) (+ (/ a (* x z)) (+ (/ t (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x z)) (log.f64 c) (/.f64 t (*.f64 x z))) (/.f64 a (*.f64 x z))) z (/.f64 z x))
(/ z x)
(/.f64 z x)
(* -1 (* z (- (* -1 (/ (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))) z)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))) z)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ a x) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))) z)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) x) (/.f64 a x)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 z))
(+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))
(+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(/ t x)
(/.f64 t x)
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (/ (* (log c) (- b 1/2)) (* t x))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x t)) (log.f64 c) (/.f64 z (*.f64 x t))) (/.f64 a (*.f64 x t))) t (/.f64 t x))
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (/ (* (log c) (- b 1/2)) (* t x))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x t)) (log.f64 c) (/.f64 z (*.f64 x t))) (/.f64 a (*.f64 x t))) t (/.f64 t x))
(* t (+ (/ 1 x) (+ (/ a (* t x)) (+ (/ z (* t x)) (/ (* (log c) (- b 1/2)) (* t x))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x t)) (log.f64 c) (/.f64 z (*.f64 x t))) (/.f64 a (*.f64 x t))) t (/.f64 t x))
(/ t x)
(/.f64 t x)
(* -1 (* t (- (* -1 (/ (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) t)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) t)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ a x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) t)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 t))
(+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))
(+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))
(+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (/.f64 a x))
(/ a x)
(/.f64 a x)
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (log.f64 c) (/.f64 z (*.f64 x a))) (/.f64 t (*.f64 x a))) a (/.f64 a x))
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (log.f64 c) (/.f64 z (*.f64 x a))) (/.f64 t (*.f64 x a))) a (/.f64 a x))
(* a (+ (/ 1 x) (+ (/ t (* a x)) (+ (/ z (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))
(fma.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (log.f64 c) (/.f64 z (*.f64 x a))) (/.f64 t (*.f64 x a))) a (/.f64 a x))
(/ a x)
(/.f64 a x)
(* -1 (* a (- (* -1 (/ (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) a)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)) (/.f64 t x)) a) (/.f64 #s(literal 1 binary64) x)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) a)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)) (/.f64 t x)) a) (/.f64 #s(literal 1 binary64) x)) (neg.f64 a))
(* -1 (* a (- (* -1 (/ (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))) a)) (/ 1 x))))
(*.f64 (-.f64 (/.f64 (-.f64 (neg.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)) (/.f64 t x)) a) (/.f64 #s(literal 1 binary64) x)) (neg.f64 a))
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x))
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x))
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x))
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) x)) (/ z x))
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x))
(+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x))
(+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x))
(+ (/ z x) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) x))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 z x))
(/ (+ z (* (log c) (- b 1/2))) x)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(/ (+ z (* (log c) (- b 1/2))) x)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) x)
(* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) x)
(* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) x)
(* -1 (/ (+ (* -1 z) (* -1 (* (log c) (- b 1/2)))) x))
(/.f64 (neg.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) x)
(+ (* -1/2 (/ (log c) x)) (/ z x))
(fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (/.f64 z x))
(+ (* -1/2 (/ (log c) x)) (+ (/ z x) (/ (* b (log c)) x)))
(fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 c) x) b (/.f64 z x)))
(+ (* -1/2 (/ (log c) x)) (+ (/ z x) (/ (* b (log c)) x)))
(fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 c) x) b (/.f64 z x)))
(+ (* -1/2 (/ (log c) x)) (+ (/ z x) (/ (* b (log c)) x)))
(fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (fma.f64 (/.f64 (log.f64 c) x) b (/.f64 z x)))
(/ (* b (log c)) x)
(*.f64 (/.f64 (log.f64 c) x) b)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ z (* b x)) (/ (log c) x))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 x b)) #s(literal -1/2 binary64) (+.f64 (/.f64 z (*.f64 x b)) (/.f64 (log.f64 c) x))) b)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ z (* b x)) (/ (log c) x))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 x b)) #s(literal -1/2 binary64) (+.f64 (/.f64 z (*.f64 x b)) (/.f64 (log.f64 c) x))) b)
(* b (+ (* -1/2 (/ (log c) (* b x))) (+ (/ z (* b x)) (/ (log c) x))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 x b)) #s(literal -1/2 binary64) (+.f64 (/.f64 z (*.f64 x b)) (/.f64 (log.f64 c) x))) b)
(/ (* b (log c)) x)
(*.f64 (/.f64 (log.f64 c) x) b)
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (/ z x)) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (/.f64 z x)) (neg.f64 b)) (/.f64 (log.f64 c) x)))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (/ z x)) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (/.f64 z x)) (neg.f64 b)) (/.f64 (log.f64 c) x)))
(* -1 (* b (+ (* -1 (/ (log c) x)) (* -1 (/ (+ (* -1/2 (/ (log c) x)) (/ z x)) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) x) #s(literal -1/2 binary64) (/.f64 z x)) (neg.f64 b)) (/.f64 (log.f64 c) x)))
(/ (* (log c) (- b 1/2)) x)
(*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(+ (/ z x) (/ (* (log c) (- b 1/2)) x))
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x)
(/ z x)
(/.f64 z x)
(* z (+ (/ 1 x) (/ (* (log c) (- b 1/2)) (* x z))))
(fma.f64 (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 x z)) z (/.f64 z x))
(* z (+ (/ 1 x) (/ (* (log c) (- b 1/2)) (* x z))))
(fma.f64 (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 x z)) z (/.f64 z x))
(* z (+ (/ 1 x) (/ (* (log c) (- b 1/2)) (* x z))))
(fma.f64 (/.f64 (*.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c)) (*.f64 x z)) z (/.f64 z x))
(/ z x)
(/.f64 z x)
(* -1 (* z (- (* -1 (/ (* (log c) (- b 1/2)) (* x z))) (/ 1 x))))
(*.f64 (neg.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x z)) (log.f64 c) (/.f64 #s(literal 1 binary64) x))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (* (log c) (- b 1/2)) (* x z))) (/ 1 x))))
(*.f64 (neg.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x z)) (log.f64 c) (/.f64 #s(literal 1 binary64) x))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (* (log c) (- b 1/2)) (* x z))) (/ 1 x))))
(*.f64 (neg.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x z)) (log.f64 c) (/.f64 #s(literal 1 binary64) x))) (neg.f64 z))
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(* -1 (/ (log (/ 1 c)) x))
(/.f64 (log.f64 c) x)
(* -1 (/ (log (/ 1 c)) x))
(/.f64 (log.f64 c) x)
(* -1 (/ (log (/ 1 c)) x))
(/.f64 (log.f64 c) x)
(* -1 (/ (log (/ 1 c)) x))
(/.f64 (log.f64 c) x)
(/ (+ (log -1) (* -1 (log (/ -1 c)))) x)
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) x)
(/ (+ (log -1) (* -1 (log (/ -1 c)))) x)
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) x)
(/ (+ (log -1) (* -1 (log (/ -1 c)))) x)
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) x)
(/ (+ (log -1) (* -1 (log (/ -1 c)))) x)
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)
(/ (log c) x)
(/.f64 (log.f64 c) x)

rewrite239.0ms (1.8%)

Memory
33.2MiB live, 379.0MiB allocated
Rules
4 352×lower-fma.f32
4 338×lower-fma.f64
4 262×lower-*.f32
4 256×lower-*.f64
3 892×lower-pow.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
051431
079431
1405424
24389422
08915403
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
24 → 438
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))
(+.f64 t a)
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
(*.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))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(log.f64 y)
(fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) 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 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) z z))
(/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x))
(+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y))
(log.f64 c)
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
(+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x))
(fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))
(/.f64 (log.f64 c) x)
Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) (fma.f64 i y z)))
(*.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))))
(*.f64 (fma.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (+.f64 a t)) (*.f64 (+.f64 a t) (+.f64 a t)))))
(pow.f64 (/.f64 (-.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z))) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (+.f64 a t)) (*.f64 (+.f64 a t) (+.f64 a t))) (fma.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))) (-.f64 (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) (fma.f64 i y z)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 2 binary64)) (*.f64 (+.f64 a t) (+.f64 a t))) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (+.f64 a t)))
(/.f64 (-.f64 (*.f64 t t) (pow.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 i y z)) #s(literal 2 binary64))) (-.f64 t (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 i y z))))
(/.f64 (+.f64 (pow.f64 (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) #s(literal 3 binary64)) (*.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z))) (+.f64 (pow.f64 (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) #s(literal 2 binary64)) (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (*.f64 (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) (fma.f64 i y z)))))
(/.f64 (fma.f64 (*.f64 t t) t (pow.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 i y z)) #s(literal 3 binary64))) (fma.f64 t t (-.f64 (pow.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 i y z)) #s(literal 2 binary64)) (*.f64 t (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 i y z))))))
(/.f64 (neg.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 2 binary64)))) (neg.f64 (-.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (+.f64 a t)) (*.f64 (+.f64 a t) (+.f64 a t)))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))) (-.f64 t a) (*.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z)) (*.f64 (+.f64 a t) (-.f64 t a)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z)) (-.f64 t a)))
(/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))) (fma.f64 a (-.f64 a t) (*.f64 t t)) (*.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z)) (fma.f64 (*.f64 a a) a (*.f64 (*.f64 t t) t)))) (*.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z)) (fma.f64 a (-.f64 a t) (*.f64 t t))))
(/.f64 (fma.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (-.f64 t a) (*.f64 (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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))) (*.f64 (+.f64 a t) (-.f64 t a)))) (*.f64 (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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))) (-.f64 t a)))
(/.f64 (fma.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 a (-.f64 a t) (*.f64 t t)) (*.f64 (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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))) (fma.f64 (*.f64 a a) a (*.f64 (*.f64 t t) t)))) (*.f64 (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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))) (fma.f64 a (-.f64 a t) (*.f64 t t))))
(/.f64 (fma.f64 (*.f64 (+.f64 a t) (-.f64 t a)) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z)) (*.f64 (-.f64 t a) (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))))) (*.f64 (-.f64 t a) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z))))
(/.f64 (fma.f64 (*.f64 (+.f64 a t) (-.f64 t a)) (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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))) (*.f64 (-.f64 t a) (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))))) (*.f64 (-.f64 t a) (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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)))))
(/.f64 (fma.f64 (fma.f64 (*.f64 a a) a (*.f64 (*.f64 t t) t)) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z)) (*.f64 (fma.f64 a (-.f64 a t) (*.f64 t t)) (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))))) (*.f64 (fma.f64 a (-.f64 a t) (*.f64 t t)) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z))))
(/.f64 (fma.f64 (fma.f64 (*.f64 a a) a (*.f64 (*.f64 t t) t)) (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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))) (*.f64 (fma.f64 a (-.f64 a t) (*.f64 t t)) (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))))) (*.f64 (fma.f64 a (-.f64 a t) (*.f64 t t)) (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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)))))
(/.f64 (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 2 binary64))) (-.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z))) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (+.f64 a t)) (*.f64 (+.f64 a t) (+.f64 a t))) (fma.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 3 binary64)))))
(/.f64 (fma.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 2 binary64)) (-.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (*.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (+.f64 a t)))))
(/.f64 (fma.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 3 binary64))) (fma.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (+.f64 a t)) (*.f64 (+.f64 a t) (+.f64 a t))))
(fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z))) (+.f64 a t))
(fma.f64 (*.f64 (+.f64 a t) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))
(fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y (neg.f64 z))) (/.f64 #s(literal 1 binary64) (fma.f64 i y (neg.f64 z))) (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))
(fma.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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)))) (+.f64 a t))
(fma.f64 (fma.f64 (*.f64 a a) a (*.f64 (*.f64 t t) t)) (/.f64 #s(literal 1 binary64) (fma.f64 a (-.f64 a t) (*.f64 t t))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))
(fma.f64 (fma.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 i y) (*.f64 (*.f64 z z) z)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 z (-.f64 z (*.f64 i y))))) (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (fma.f64 i y z) (+.f64 a t)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 (fma.f64 i y z) (+.f64 a t)))
(-.f64 (/.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (-.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))) (/.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) #s(literal 2 binary64)) (-.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))))
(+.f64 (+.f64 (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) (*.f64 i y)) z)
(+.f64 (+.f64 (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) z) (*.f64 i y))
(+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) t) a)
(+.f64 (+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y))) z)
(+.f64 (+.f64 (+.f64 a t) (fma.f64 i y z)) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 i y z)) t)
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) (+.f64 z (+.f64 a t)))
(+.f64 (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) (fma.f64 i y z))
(+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (fma.f64 i y z) (+.f64 a t)))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)) (+.f64 a t))
(+.f64 (fma.f64 i y z) (+.f64 a (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))
(+.f64 (+.f64 a t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z)))
(+.f64 a (+.f64 t (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z))))
(+.f64 t (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 i y z)))
(*.f64 (*.f64 (+.f64 a t) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)))
(*.f64 (fma.f64 (*.f64 a a) a (*.f64 (*.f64 t t) t)) (/.f64 #s(literal 1 binary64) (fma.f64 a (-.f64 a t) (*.f64 t t))))
(pow.f64 (/.f64 (-.f64 t a) (*.f64 (+.f64 a t) (-.f64 t a))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 a (-.f64 a t) (*.f64 t t)) (fma.f64 (*.f64 a a) a (*.f64 (*.f64 t t) t))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 a a) (*.f64 t t)) (-.f64 a t))
(/.f64 (neg.f64 (*.f64 (+.f64 a t) (-.f64 t a))) (neg.f64 (-.f64 t a)))
(/.f64 (neg.f64 (fma.f64 (*.f64 a a) a (*.f64 (*.f64 t t) t))) (neg.f64 (fma.f64 a (-.f64 a t) (*.f64 t t))))
(/.f64 (*.f64 (+.f64 a t) (-.f64 t a)) (-.f64 t a))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 a t) (-.f64 t a))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 a (-.f64 a t) (*.f64 t t)) (fma.f64 (*.f64 a a) a (*.f64 (*.f64 t t) t))))
(/.f64 (fma.f64 (*.f64 a a) a (*.f64 (*.f64 t t) t)) (fma.f64 a a (-.f64 (*.f64 t t) (*.f64 a t))))
(/.f64 (fma.f64 (*.f64 a a) a (*.f64 (*.f64 t t) t)) (fma.f64 a (-.f64 a t) (*.f64 t t)))
(-.f64 (/.f64 (*.f64 t t) (-.f64 t a)) (/.f64 (*.f64 a a) (-.f64 t a)))
(+.f64 a t)
(+.f64 t a)
(*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z))))
(*.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z)) (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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))) (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) #s(literal 2 binary64)) (*.f64 z z)) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z))
(/.f64 (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (fma.f64 i y z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) #s(literal 3 binary64)) (*.f64 (*.f64 z z) z)) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) #s(literal 2 binary64)) (-.f64 (*.f64 z z) (*.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z)))) (neg.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z)) (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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))) (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))))
(/.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 (fma.f64 i y z) (fma.f64 i y z) (-.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))) (fma.f64 i y z)))))
(/.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 (fma.f64 i y z) (-.f64 (fma.f64 i y 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))))
(fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y (neg.f64 z))) (/.f64 #s(literal 1 binary64) (fma.f64 i y (neg.f64 z))) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (fma.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 i y) (*.f64 (*.f64 z z) z)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 z (-.f64 z (*.f64 i y))))) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 i y z))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y z))
(fma.f64 i y (+.f64 z (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(fma.f64 y i (+.f64 z (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z))) (/.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z))))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) z) (*.f64 i y))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z)
(+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 i y z))
(+.f64 (*.f64 i y) (+.f64 z (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(+.f64 (fma.f64 i y z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 z (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)))
#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 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y)) (/.f64 #s(literal 1 binary64) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 i y))))
(*.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 i y)) (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))) (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y))) (neg.f64 (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 i y))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y)) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 i y)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 i y)) (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))) (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)))))
(/.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 i y) i) y (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 i y)))))
(/.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 3 binary64))) (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))))
(fma.f64 i y #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
(-.f64 (/.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 i y))) (/.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 i y))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)) (*.f64 i y))
(+.f64 (*.f64 i 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))) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(*.f64 x (log.f64 y))
(log.f64 y)
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) z)) z)
(*.f64 (fma.f64 (pow.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 (neg.f64 z) z)) (/.f64 #s(literal 1 binary64) (fma.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64) (neg.f64 z))))
(*.f64 (fma.f64 (*.f64 z z) z (pow.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)) t))) a) #s(literal 1 binary64)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (pow.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 z (-.f64 z (*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64)))))))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) z)))
(pow.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64) (neg.f64 z)) (fma.f64 (pow.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 (neg.f64 z) z))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (pow.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 z (-.f64 z (*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64))))) (fma.f64 (*.f64 z z) z (pow.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)) t))) a) #s(literal 1 binary64)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 z z) (pow.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)) t))) a) #s(literal 1 binary64)) #s(literal 2 binary64))) (-.f64 z (*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 (neg.f64 z) z))) (neg.f64 (fma.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64) (neg.f64 z))))
(/.f64 (neg.f64 (fma.f64 (*.f64 z z) z (pow.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)) t))) a) #s(literal 1 binary64)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (pow.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 z (-.f64 z (*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64)))))))
(/.f64 (fma.f64 (pow.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 (neg.f64 z) z)) (fma.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64) (neg.f64 z)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64) (neg.f64 z)) (fma.f64 (pow.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 (neg.f64 z) z))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (pow.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 z (-.f64 z (*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64))))) (fma.f64 (*.f64 z z) z (pow.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)) t))) a) #s(literal 1 binary64)) #s(literal 3 binary64)))))
(/.f64 (fma.f64 (*.f64 z z) z (pow.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)) t))) a) #s(literal 1 binary64)) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.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)) t))) a) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.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)) t))) a) #s(literal 1 binary64)) z))))
(/.f64 (fma.f64 (*.f64 z z) z (pow.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)) t))) a) #s(literal 1 binary64)) #s(literal 3 binary64))) (fma.f64 (pow.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 z (-.f64 z (*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64))))))
(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)) t))) a) z) (/.f64 #s(literal 1 binary64) 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)) t))) a) z) z z)
(fma.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) (/.f64 z z) z)
(fma.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64) z)
(fma.f64 z (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) z) z)
(-.f64 (/.f64 (pow.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)) t))) a) #s(literal 1 binary64)) #s(literal 2 binary64)) (fma.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64) (neg.f64 z))) (/.f64 (*.f64 z z) (fma.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64) (neg.f64 z))))
(+.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)) t))) a) #s(literal 1 binary64)) z)
(+.f64 z (*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64)))
#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 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) #s(literal 1 binary64) z))
(*.f64 (pow.f64 (/.f64 z (-.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)) (*.f64 a a))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)))
(*.f64 (pow.f64 (/.f64 z (fma.f64 (*.f64 a a) a (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 3 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 a (-.f64 a (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))) (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)))))
(*.f64 (/.f64 #s(literal 1 binary64) z) (pow.f64 (/.f64 #s(literal 1 binary64) (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) z) (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a))
(*.f64 #s(literal 1 binary64) (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) z))
(*.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)) t))) a)) (/.f64 #s(literal 1 binary64) (neg.f64 z)))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) (/.f64 #s(literal 1 binary64) z))
(pow.f64 (/.f64 (/.f64 z (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 z (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)) #s(literal -1 binary64))
(/.f64 (*.f64 (-.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) z)) (-.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a))
(/.f64 (*.f64 (fma.f64 (*.f64 a a) a (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) z)) (fma.f64 a (-.f64 a (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))) (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64))))
(/.f64 (neg.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)) t))) a))) (neg.f64 (neg.f64 z)))
(/.f64 (*.f64 (-.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)) (*.f64 a a)) #s(literal 1 binary64)) (*.f64 (-.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) z))
(/.f64 (*.f64 (fma.f64 (*.f64 a a) a (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 3 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 a (-.f64 a (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))) (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64))) z))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 z (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a))))
(/.f64 (-.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)) (*.f64 a a)) (*.f64 z (-.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 z (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 z (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)))
(/.f64 (fma.f64 (*.f64 a a) a (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 3 binary64))) (*.f64 z (fma.f64 a (-.f64 a (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))) (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)))))
(/.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)) t))) a)) (neg.f64 z))
(/.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)) t))) a) #s(literal 1 binary64)) z)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) z)
(neg.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)) t))) a)) z))
(neg.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)) t))) a) (neg.f64 z)))
(exp.f64 (*.f64 (log.f64 (/.f64 z (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a))) #s(literal -1 binary64)))
(*.f64 (-.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)))
(*.f64 (fma.f64 (*.f64 a a) a (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 a (-.f64 a (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))) (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)))))
(pow.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)) t))) a) (-.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)) (*.f64 a a))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 a (-.f64 a (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))) (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64))) (fma.f64 (*.f64 a a) a (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) a) #s(literal 2 binary64))) (-.f64 (*.f64 i y) (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) a)))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64))) (-.f64 a (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))))
(/.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) a) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 i y) i) y (-.f64 (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) a) #s(literal 2 binary64)) (*.f64 (*.f64 i y) (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) a)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)) (*.f64 a a))) (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)) t))) a)))
(/.f64 (neg.f64 (fma.f64 (*.f64 a a) a (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 a (-.f64 a (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))) (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)) (*.f64 a a)) (-.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a) (-.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)) (*.f64 a a))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 a (-.f64 a (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))) (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64))) (fma.f64 (*.f64 a a) a (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 3 binary64)))))
(/.f64 (fma.f64 (*.f64 a a) a (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 3 binary64))) (fma.f64 a a (-.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)) (*.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a))))
(/.f64 (fma.f64 (*.f64 a a) a (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 3 binary64))) (fma.f64 a (-.f64 a (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))) (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64))))
(fma.f64 (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 i y) (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))) a)
(fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) (fma.f64 i y a))
(fma.f64 (fma.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 i y) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) (*.f64 i y))))) a)
(fma.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))) (fma.f64 i y a))
(fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) a))
(fma.f64 y i (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) a))
(-.f64 (/.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) #s(literal 2 binary64)) (-.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)) (/.f64 (*.f64 a a) (-.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)))
(+.f64 (+.f64 a (fma.f64 (log.f64 y) x (*.f64 i y))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))
(+.f64 (+.f64 a (*.f64 i y)) (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))
(+.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) a) (*.f64 i y))
(+.f64 (fma.f64 (log.f64 y) x (*.f64 i y)) (+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) a))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) a)
(+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) (fma.f64 i y a))
(+.f64 (*.f64 i y) (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) a))
(+.f64 a (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))))
(*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)
(*.f64 x (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)))
(/.f64 (*.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64))) x) (-.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)))
(/.f64 (*.f64 (+.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 3 binary64))) x) (fma.f64 (log.f64 y) (-.f64 (log.f64 y) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64))))
(/.f64 (*.f64 x (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64)))) (-.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)))
(/.f64 (*.f64 x (+.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 3 binary64)))) (fma.f64 (log.f64 y) (-.f64 (log.f64 y) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) x (*.f64 (log.f64 y) x))
(fma.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) x (*.f64 (+.f64 (/.f64 a x) (log.f64 y)) x))
(fma.f64 (log.f64 y) x (*.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) x))
(fma.f64 (log.f64 y) x (*.f64 x (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))))
(fma.f64 x (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (*.f64 (log.f64 y) x))
(fma.f64 x (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (*.f64 x (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 x (log.f64 y) (*.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) x))
(fma.f64 x (log.f64 y) (*.f64 x (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))))
(+.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) x) (*.f64 (+.f64 (/.f64 a x) (log.f64 y)) x))
(+.f64 (*.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) x) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 x (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))) (*.f64 x (+.f64 (/.f64 a x) (log.f64 y))))
(+.f64 (*.f64 x (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) (*.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) x))
(+.f64 (*.f64 (log.f64 y) x) (*.f64 x (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))))
(*.f64 (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y)) (/.f64 #s(literal 1 binary64) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) (*.f64 i y))))
(*.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) (*.f64 i y)) (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64))) (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64))) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y))) (neg.f64 (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) (*.f64 i y))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y)) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) (*.f64 i y)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) (*.f64 i y)) (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64))) (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 3 binary64)))))
(/.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 i y) i) y (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64)) (*.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) (*.f64 i y)))))
(/.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 3 binary64))) (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64))))
(fma.f64 i y #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)))
(-.f64 (/.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) #s(literal 2 binary64)) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) (*.f64 i y))) (/.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) (*.f64 i y))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)) (*.f64 i y))
(+.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x)))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) x))
(*.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y))))
(*.f64 (+.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 y) (-.f64 (log.f64 y) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (-.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (log.f64 y) (-.f64 (log.f64 y) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64))) (+.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (pow.f64 (+.f64 (/.f64 a x) (log.f64 y)) #s(literal 2 binary64))) (-.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (+.f64 (/.f64 a x) (log.f64 y))))
(/.f64 (-.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64))) (-.f64 (log.f64 y) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 3 binary64)) (pow.f64 (+.f64 (/.f64 a x) (log.f64 y)) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 (/.f64 a x) (log.f64 y)) #s(literal 2 binary64)) (*.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (+.f64 (/.f64 a x) (log.f64 y))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64)))) (neg.f64 (-.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (log.f64 y) (-.f64 (log.f64 y) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64))) (-.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)) (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64)) (pow.f64 (log.f64 y) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) (-.f64 (log.f64 y) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64))) (+.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 3 binary64)))))
(/.f64 (+.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64)) (*.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y)))))
(/.f64 (+.f64 (pow.f64 (log.f64 y) #s(literal 3 binary64)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 3 binary64))) (fma.f64 (log.f64 y) (-.f64 (log.f64 y) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64))))
(fma.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 x x))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x))) (+.f64 (/.f64 a x) (log.f64 y)))
(fma.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 x x))) (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z) x)) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (log.f64 y)))
(fma.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 x x))) (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z) x)) (+.f64 (/.f64 t x) (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (/.f64 (*.f64 a a) (*.f64 x x))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z)) (/.f64 a x)))) (log.f64 y))
(fma.f64 (/.f64 #s(literal 1 binary64) x) (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)) (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 (/.f64 #s(literal 1 binary64) x) (pow.f64 (/.f64 #s(literal 1 binary64) a) #s(literal -1 binary64)) (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (log.f64 y)))
(fma.f64 (/.f64 #s(literal 1 binary64) x) a (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (log.f64 y)))
(fma.f64 (/.f64 #s(literal 1 binary64) x) t (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 #s(literal 1 binary64) (/.f64 a x) (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (log.f64 y)))
(fma.f64 #s(literal 1 binary64) (/.f64 t x) (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)))) (+.f64 (/.f64 a x) (log.f64 y)))
(fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 z x) (-.f64 (/.f64 z x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (log.f64 y)))
(fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 z x) (-.f64 (/.f64 z x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))) (+.f64 (/.f64 t x) (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 a x) (-.f64 (/.f64 a x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)))) (log.f64 y))
(fma.f64 (neg.f64 t) (/.f64 #s(literal 1 binary64) (neg.f64 x)) (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 (neg.f64 a) (/.f64 #s(literal 1 binary64) (neg.f64 x)) (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (log.f64 y)))
(fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 (log.f64 c) (*.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (+.f64 (/.f64 a x) (log.f64 y))))
(fma.f64 a (/.f64 #s(literal 1 binary64) x) (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (log.f64 y)))
(fma.f64 t (/.f64 #s(literal 1 binary64) x) (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (+.f64 (/.f64 a x) (log.f64 y))))
(-.f64 (/.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) #s(literal 2 binary64)) (-.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y))) (/.f64 (pow.f64 (log.f64 y) #s(literal 2 binary64)) (-.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y))))
(+.f64 (+.f64 (log.f64 y) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))) (/.f64 a x))
(+.f64 (+.f64 (log.f64 y) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t)))
(+.f64 (+.f64 (/.f64 a x) (log.f64 y)) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))))
(+.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (+.f64 (/.f64 a x) (log.f64 y))))
(+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (log.f64 y))
(+.f64 (/.f64 a x) (+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (log.f64 y)))
(+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (+.f64 (/.f64 a x) (log.f64 y)))
(+.f64 (/.f64 t x) (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (+.f64 (/.f64 a x) (log.f64 y))))
(+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (log.f64 y)))
(+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (+.f64 (/.f64 t x) (+.f64 (/.f64 a x) (log.f64 y))))
(+.f64 (log.f64 y) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))))
(log.f64 c)
(*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t))))
(*.f64 (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 t (-.f64 t (*.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 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 t t))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 t (-.f64 t (*.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))) (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 t t) (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 t (*.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 2 binary64)) (*.f64 t t))) (neg.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t))))
(/.f64 (neg.f64 (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 t (-.f64 t (*.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)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 t t)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 t t))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 t (-.f64 t (*.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))) (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))))
(/.f64 (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 t t (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (log.f64 c) (*.f64 (-.f64 b #s(literal 1/2 binary64)) t)))))
(/.f64 (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 t (-.f64 t (*.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))))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t))) (/.f64 (*.f64 t t) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t))))
(+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) t)
(+.f64 t (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))))
(*.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (*.f64 t t)) (-.f64 (fma.f64 (log.f64 y) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) t))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (*.f64 (log.f64 y) x)))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 3 binary64)) (*.f64 (*.f64 t t) t)) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (-.f64 (*.f64 t t) (*.f64 (fma.f64 (log.f64 y) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) t))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (*.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)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 2 binary64))) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (*.f64 (log.f64 y) x)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (-.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))))
(fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t))) (*.f64 (log.f64 y) x))
(fma.f64 (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 t (-.f64 t (*.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)))) (*.f64 (log.f64 y) x))
(fma.f64 (log.f64 y) x (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 t (*.f64 (log.f64 y) x)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 t (*.f64 (log.f64 y) x)))
(fma.f64 x (log.f64 y) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))) (/.f64 (pow.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))))
(+.f64 (fma.f64 (log.f64 y) x t) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (fma.f64 (log.f64 y) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))) t)
(+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 t (*.f64 (log.f64 y) x)))
(+.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t))
(+.f64 t (fma.f64 (log.f64 y) x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)))))
(*.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (/.f64 (*.f64 a a) (*.f64 x x))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z)) (/.f64 a x)))))
(*.f64 (+.f64 (/.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 a x) (-.f64 (/.f64 a x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z)) (/.f64 a x))) (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (/.f64 (*.f64 a a) (*.f64 x x)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (/.f64 a x) (-.f64 (/.f64 a x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (/.f64 (*.f64 a a) (*.f64 x x)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64))) (-.f64 (/.f64 a x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t)))) (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 3 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 x x) x)) (*.f64 (*.f64 (+.f64 a t) (+.f64 a t)) (+.f64 a t)))) (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))) (*.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (/.f64 (*.f64 a a) (*.f64 x x)))) (neg.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z)) (/.f64 a x)))))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (/.f64 a x) (-.f64 (/.f64 a x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)))))
(/.f64 (fma.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (*.f64 (/.f64 x a) (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 x x))))) (*.f64 (/.f64 x a) (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x))))
(/.f64 (fma.f64 #s(literal 1 binary64) (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64))) (*.f64 (/.f64 x a) (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 3 binary64))))) (*.f64 (/.f64 x a) (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (neg.f64 a) (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (*.f64 (neg.f64 x) (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 x x))))) (*.f64 (neg.f64 x) (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x))))
(/.f64 (fma.f64 (neg.f64 a) (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64))) (*.f64 (neg.f64 x) (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 3 binary64))))) (*.f64 (neg.f64 x) (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)))))
(/.f64 (fma.f64 a (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (*.f64 x (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 x x))))) (*.f64 x (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x))))
(/.f64 (fma.f64 a (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64))) (*.f64 x (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 3 binary64))))) (*.f64 x (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 x x))) (/.f64 x a) (*.f64 (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) #s(literal 1 binary64))) (*.f64 (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 x a)))
(/.f64 (fma.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 x x))) (neg.f64 x) (*.f64 (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (neg.f64 a))) (*.f64 (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (neg.f64 x)))
(/.f64 (fma.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 x x))) x (*.f64 (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) a)) (*.f64 (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) x))
(/.f64 (fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 3 binary64))) (/.f64 x a) (*.f64 (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64))) #s(literal 1 binary64))) (*.f64 (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64))) (/.f64 x a)))
(/.f64 (fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 3 binary64))) (neg.f64 x) (*.f64 (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64))) (neg.f64 a))) (*.f64 (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64))) (neg.f64 x)))
(/.f64 (fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 3 binary64))) x (*.f64 (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64))) a)) (*.f64 (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64))) x))
(/.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (/.f64 (*.f64 a a) (*.f64 x x))) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z)) (/.f64 a x))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z)) (/.f64 a x))) (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (/.f64 (*.f64 a a) (*.f64 x x)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 a x) (-.f64 (/.f64 a x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 3 binary64)))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 3 binary64))) (+.f64 (/.f64 (*.f64 a a) (*.f64 x x)) (-.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (*.f64 (/.f64 a x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 a a) a) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 3 binary64))) (fma.f64 (/.f64 a x) (-.f64 (/.f64 a x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))) (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64))))
(fma.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 x x))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x))) (/.f64 a x))
(fma.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 x x))) (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z) x)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t)))
(fma.f64 (/.f64 #s(literal 1 binary64) x) (pow.f64 (/.f64 #s(literal 1 binary64) z) #s(literal -1 binary64)) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(fma.f64 (/.f64 #s(literal 1 binary64) x) (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)) (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 a x)))
(fma.f64 (/.f64 #s(literal 1 binary64) x) (pow.f64 (/.f64 #s(literal 1 binary64) a) #s(literal -1 binary64)) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))
(fma.f64 (/.f64 #s(literal 1 binary64) x) a (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))))
(fma.f64 (/.f64 #s(literal 1 binary64) x) t (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 a x)))
(fma.f64 (/.f64 #s(literal 1 binary64) x) z (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(fma.f64 #s(literal 1 binary64) (/.f64 a x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))))
(fma.f64 #s(literal 1 binary64) (/.f64 t x) (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 a x)))
(fma.f64 #s(literal 1 binary64) (/.f64 z x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 x x) x)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 t x) (-.f64 (/.f64 t x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) #s(literal 2 binary64)))) (/.f64 a x))
(fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 z x) (-.f64 (/.f64 z x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t)))
(fma.f64 (neg.f64 t) (/.f64 #s(literal 1 binary64) (neg.f64 x)) (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 a x)))
(fma.f64 (neg.f64 a) (/.f64 #s(literal 1 binary64) (neg.f64 x)) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))))
(fma.f64 (neg.f64 z) (/.f64 #s(literal 1 binary64) (neg.f64 x)) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (/.f64 a x)))
(fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) x) (+.f64 (/.f64 z x) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (/.f64 a x)))
(fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (/.f64 z x) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (/.f64 a x)))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (+.f64 (/.f64 z x) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(fma.f64 (log.f64 c) (*.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (/.f64 a x)))
(fma.f64 (log.f64 c) (*.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (/.f64 z x) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (/.f64 a x)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) x) (+.f64 (/.f64 z x) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(fma.f64 a (/.f64 #s(literal 1 binary64) x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))))
(fma.f64 t (/.f64 #s(literal 1 binary64) x) (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 a x)))
(fma.f64 z (/.f64 #s(literal 1 binary64) x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(-.f64 (/.f64 (pow.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) #s(literal 2 binary64)) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z)) (/.f64 a x)))) (/.f64 (/.f64 (*.f64 a a) (*.f64 x x)) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (-.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z)) (/.f64 a x)))))
(+.f64 (+.f64 (/.f64 a x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z)))
(+.f64 (+.f64 (/.f64 a x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))) (/.f64 t x))
(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t)) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)))
(+.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (/.f64 a x)))
(+.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (/.f64 z x) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(+.f64 (/.f64 a x) (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))))
(+.f64 (fma.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 t z) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (/.f64 a x))
(+.f64 (/.f64 t x) (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 a x)))
(+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t)))
(+.f64 (/.f64 z x) (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) x) (+.f64 a t))))
(*.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 x x))) (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z) x)))
(*.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 z x) (-.f64 (/.f64 z x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (/.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z) x) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 x x)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (/.f64 z x) (-.f64 (/.f64 z x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (/.f64 (*.f64 z z) (*.f64 x x)) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (/.f64 z x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 x x)))) (neg.f64 (/.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z) x)))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (/.f64 z x) (-.f64 (/.f64 z x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (/.f64 x z) (*.f64 x #s(literal 1 binary64))) (*.f64 x (/.f64 x z)))
(/.f64 (fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (neg.f64 x) (*.f64 x (neg.f64 z))) (*.f64 x (neg.f64 x)))
(/.f64 (fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) x (*.f64 x z)) (*.f64 x x))
(/.f64 (fma.f64 #s(literal 1 binary64) x (*.f64 (/.f64 x z) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) (*.f64 (/.f64 x z) x))
(/.f64 (fma.f64 (neg.f64 z) x (*.f64 (neg.f64 x) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) (*.f64 (neg.f64 x) x))
(/.f64 (fma.f64 z x (*.f64 x (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) (*.f64 x x))
(/.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 x x))) (/.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z) x))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z) x) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 x x)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 z x) (-.f64 (/.f64 z x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (/.f64 (*.f64 z z) (*.f64 x x)) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z) (*.f64 x x)))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 x x) x)) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 z x) (-.f64 (/.f64 z x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) x) (pow.f64 (/.f64 #s(literal 1 binary64) z) #s(literal -1 binary64)) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) x) z (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1 binary64) (/.f64 z x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (neg.f64 z) (/.f64 #s(literal 1 binary64) (neg.f64 x)) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) x) (/.f64 z x))
(fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 z x))
(fma.f64 (log.f64 c) (*.f64 (/.f64 #s(literal 1 binary64) x) (-.f64 b #s(literal 1/2 binary64))) (/.f64 z x))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) x) (/.f64 z x))
(fma.f64 z (/.f64 #s(literal 1 binary64) x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))
(-.f64 (/.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z) x)) (/.f64 (/.f64 (*.f64 z z) (*.f64 x x)) (/.f64 (-.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) z) x)))
(+.f64 (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))) (/.f64 z x))
(+.f64 (/.f64 z x) (*.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64))))
(*.f64 (/.f64 #s(literal 1 binary64) x) (pow.f64 (/.f64 #s(literal 1 binary64) (log.f64 c)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) x) (log.f64 c))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 c) x))
(*.f64 (neg.f64 (log.f64 c)) (/.f64 #s(literal 1 binary64) (neg.f64 x)))
(*.f64 (log.f64 c) (/.f64 #s(literal 1 binary64) x))
(pow.f64 (/.f64 (/.f64 x (log.f64 c)) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 x (log.f64 c)) #s(literal -1 binary64))
(/.f64 (*.f64 (log.f64 c) #s(literal 1 binary64)) x)
(/.f64 (neg.f64 (neg.f64 (log.f64 c))) (neg.f64 (neg.f64 x)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 x (log.f64 c))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 x (log.f64 c)) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 x (log.f64 c)))
(/.f64 (neg.f64 (log.f64 c)) (neg.f64 x))
(/.f64 (log.f64 c) x)
(neg.f64 (/.f64 (neg.f64 (log.f64 c)) x))
(neg.f64 (/.f64 (log.f64 c) (neg.f64 x)))
(exp.f64 (*.f64 (log.f64 (/.f64 x (log.f64 c))) #s(literal -1 binary64)))

eval320.0ms (2.4%)

Memory
19.6MiB live, 631.3MiB allocated
Compiler

Compiled 56 771 to 2 826 computations (95% saved)

prune385.0ms (2.9%)

Memory
5.7MiB live, 466.9MiB allocated
Pruning

30 alts after pruning (29 fresh and 1 done)

PrunedKeptTotal
New2 017212 038
Fresh6814
Picked415
Done000
Total2 027302 057
Accuracy
100.0%
Counts
2 057 → 30
Alt Table
Click to see full alt table
StatusAccuracyProgram
37.4%
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
▶80.3%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i))
75.8%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x z))) b) (log.f64 c)) b)) (*.f64 y i))
60.2%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
48.9%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 #s(approx (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
32.8%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
35.6%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
33.5%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (*.f64 (/.f64 (log.f64 c) x) b)) x)) (*.f64 y i))
56.5%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 t))) x)) (*.f64 y i))
44.2%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.f64 y i))
60.7%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (* (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) x) (*.f64 (neg.f64 a) (fma.f64 x (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) (neg.f64 a)) #s(literal -1 binary64))))) (*.f64 y i))
63.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i #s(approx (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t)) (*.f64 (log.f64 y) x))) a) z) z z))
▶79.8%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a))
▶28.9%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z))
41.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
66.1%
#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)) t))) a) z) (/.f64 #s(literal 1 binary64) z) z))
21.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
34.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
33.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (/.f64 (log.f64 c) z) b)) z z))
76.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
72.3%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) z z))))
62.7%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
66.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))))
▶45.1%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
42.6%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
67.1%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 t i)) (fma.f64 (/.f64 x i) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) i) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z i)))) i))
▶14.9%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
✓24.4%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
22.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
51.8%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ t a) (+ (* (- b 1/2) (log c)) (+ (* y i) z))) (fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 y i) t)) (/.f64 z t)) (/.f64 a t)) t t)))
Compiler

Compiled 1 424 to 899 computations (36.9% saved)

simplify308.0ms (2.3%)

Memory
-20.6MiB live, 173.2MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 19 expressions of interest:

NewMetricScoreProgram
cost-diff0
(+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
cost-diff0
(/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
cost-diff0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a))
cost-diff896
(fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)
cost-diff0
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
cost-diff0
(/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
cost-diff0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z))
cost-diff896
(fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)
cost-diff0
(log.f64 y)
cost-diff0
(*.f64 (log.f64 y) x)
cost-diff0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
cost-diff0
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))
cost-diff0
(+.f64 t a)
cost-diff0
(+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))
cost-diff0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
cost-diff0
(+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)))
cost-diff0
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a))
cost-diff128
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i))
cost-diff3008
(fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)
Rules
14 486×lower-fma.f32
14 470×lower-fma.f64
2 970×lower-*.f32
2 966×lower-*.f64
2 636×lower-+.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
058571
089571
1162571
2374551
31320543
42324516
53886516
64600516
76667516
08049508
Stop Event
1×iter limit
1×node limit
1×iter limit
Calls
Call 1
Inputs
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a))
(fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)
(+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)))
(fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a))
(/.f64 x a)
x
a
(log.f64 y)
y
(/.f64 z a)
z
(fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))
(/.f64 (log.f64 c) a)
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(/.f64 t a)
t
(*.f64 y i)
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
(+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))
(+.f64 t a)
t
a
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))
(*.f64 y i)
y
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(log.f64 y)
y
x
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z))
(fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)
(/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(log.f64 y)
y
x
z
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)
(/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
(fma.f64 y i z)
y
i
z
(fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
(log.f64 y)
x
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
t
a
Outputs
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i))
(fma.f64 i y #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 x (log.f64 y) (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a) z) t))))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 x (log.f64 y) (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a) z) t)))
(fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)
(fma.f64 x (log.f64 y) (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a) z) t))
(+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 t a)) (/.f64 z a)))
(fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(/.f64 x a)
x
a
(log.f64 y)
y
(/.f64 z a)
z
(fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 t a))
(/.f64 (log.f64 c) a)
(log.f64 c)
c
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(/.f64 t a)
t
(*.f64 y i)
(*.f64 i y)
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 a t)))
(+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))
(+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 a t))
(+.f64 t a)
(+.f64 a t)
t
a
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))
(*.f64 y i)
(*.f64 i y)
y
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 x (log.f64 y)))
(*.f64 (log.f64 y) x)
(*.f64 x (log.f64 y))
(log.f64 y)
y
x
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) 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 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 x (log.f64 y))) z))
(fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)
(+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 x (log.f64 y))) z)
(/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
(/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 x (log.f64 y))) z)
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 x (log.f64 y)))
(*.f64 (log.f64 y) x)
(*.f64 x (log.f64 y))
(log.f64 y)
y
x
z
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 x (log.f64 y) (+.f64 (fma.f64 i y (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a) t)) z)))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)
(fma.f64 x (log.f64 y) (+.f64 (fma.f64 i y (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a) t)) z))
(/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(/.f64 (fma.f64 x (log.f64 y) (fma.f64 i y (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) z))) a)
(+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
(fma.f64 x (log.f64 y) (fma.f64 i y (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) z)))
(fma.f64 y i z)
(fma.f64 i y z)
y
i
z
(fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
(fma.f64 x (log.f64 y) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
(log.f64 y)
x
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(log.f64 c)
c
t
a

localize259.0ms (1.9%)

Memory
-42.7MiB live, 190.7MiB allocated
Localize:

Found 19 expressions of interest:

NewMetricScoreProgram
accuracy0.07421875
(fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
accuracy0.140625
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
accuracy3.4231847134349014
(/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
accuracy12.920014404633413
(fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)
accuracy0.25390625
(*.f64 (log.f64 y) x)
accuracy3.1891038189830785
(/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
accuracy13.505404141311258
(fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)
accuracy53.38495315841574
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
accuracy0
(log.f64 y)
accuracy0.25390625
(*.f64 (log.f64 y) x)
accuracy54.43873717987634
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
accuracy0
(*.f64 y i)
accuracy0.00390625
(+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))
accuracy9.05916299124386
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
accuracy44.21229274609985
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))
accuracy0.3789041858302058
(fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))
accuracy1.2109333716604118
(fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a))
accuracy1.3164021216604118
(+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)))
accuracy12.254247395439274
(fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)
Samples
116.0ms255×0valid
1.0ms1×1valid
Compiler

Compiled 455 to 49 computations (89.2% saved)

Precisions
Click to see histograms. Total time spent on operations: 90.0ms
ival-add: 58.0ms (64.2% of total)
ival-mult: 14.0ms (15.5% of total)
ival-div: 10.0ms (11.1% of total)
ival-log: 7.0ms (7.8% of total)
ival-sub: 1.0ms (1.1% 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)

series213.0ms (1.6%)

Memory
25.3MiB live, 372.5MiB allocated
Counts
24 → 1 704
Calls
Call 1
Inputs
#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())
#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())
#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())
#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())
#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())
#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())
#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())
#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())
#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())
#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())
#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())
#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())
#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())
#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())
#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())
#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())
#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())
#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())
Outputs
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y)))) (taylor 0 x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y)))) (taylor 0 x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y)))) (taylor 0 x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x)))) (taylor inf x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x)))) (taylor inf x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x)))) (taylor inf x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1))) (taylor -inf a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1))) (taylor -inf a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1))) (taylor -inf a) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor -inf y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor -inf y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor -inf y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor -inf y) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)))) (taylor inf z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)))) (taylor inf z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)))) (taylor inf z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) (taylor inf c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) (taylor inf c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) (taylor inf c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) (taylor inf c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))) (taylor -inf c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))) (taylor -inf c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))) (taylor -inf c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))) (taylor -inf c) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) (taylor 0 b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b)))) (taylor inf b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b)))) (taylor inf b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b)))) (taylor inf b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)))) (taylor inf t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)))) (taylor inf t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)))) (taylor inf t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) (patch (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) (patch (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* (log c) (- b 1/2))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (patch #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) a) (taylor inf x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))) (taylor inf x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))) (taylor inf x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))) (taylor inf x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) a) (taylor -inf x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x))))) (taylor -inf x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x))))) (taylor -inf x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x))))) (taylor -inf x) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor inf a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor inf a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor inf a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor inf a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a)) (taylor -inf a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a)) (taylor -inf a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a)) (taylor -inf a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a)) (taylor -inf a) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (taylor inf y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (taylor inf y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (taylor inf y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (taylor inf y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) (taylor -inf y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) (taylor -inf y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) (taylor -inf y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) (taylor -inf y) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor inf z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))) (taylor inf z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))) (taylor inf z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))) (taylor inf z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor -inf z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) (taylor inf c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) (taylor inf c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) (taylor inf c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) (taylor inf c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a))))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a))))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a))))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor inf b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b))))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b))))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b))))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor -inf b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (patch (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))) (taylor 0 b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b))))))) (taylor inf b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b))))) (taylor -inf b) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* (log c) (- b 1/2))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* (log c) (- b 1/2))))) (taylor 0 i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt a (taylor 0 t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt t (taylor 0 a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt (+.f64 t a) (patch (+.f64 t a) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (* i y))) (taylor 0 b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))) (taylor 0 b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))) (taylor 0 b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))) (taylor 0 b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b))))) (taylor inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b))))) (taylor inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b))))) (taylor inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (* (log c) (- b 1/2))) (taylor 0 y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))) (taylor inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))) (taylor inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))) (taylor inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (* (log c) (- b 1/2))) (taylor 0 i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))) (taylor inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))) (taylor inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))) (taylor inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ (* i y) (* (log c) (- b 1/2))) (taylor 0 z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) (taylor inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) (taylor inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) (taylor inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (log y) (taylor 0 y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (log y) (taylor 0 y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (log y) (taylor 0 y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (log y) (taylor 0 y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 y))) (taylor inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 y))) (taylor inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 y))) (taylor inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 y))) (taylor inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 y)))) (taylor -inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 y)))) (taylor -inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 y)))) (taylor -inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 y)))) (taylor -inf y) (#s(alt (log.f64 y) (patch (log.f64 y) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) (patch (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z) (taylor 0 y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) z) (taylor inf y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z))))))) (taylor inf y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z))))))) (taylor inf y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z))))))) (taylor inf y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) z) (taylor -inf y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -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))))) (taylor -inf y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -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))))) (taylor -inf y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -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))))) (taylor -inf y) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z) (taylor 0 i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) z) (taylor inf i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z))))))) (taylor inf i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z))))))) (taylor inf i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z))))))) (taylor inf i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) z) (taylor -inf i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i))))) (taylor -inf i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i))))) (taylor -inf i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i))))) (taylor -inf i) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z) (taylor 0 x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) z) (taylor inf x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))) (taylor inf x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))) (taylor inf x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z))))))) (taylor inf x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) z) (taylor -inf x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x))))) (taylor -inf x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x))))) (taylor -inf x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x))))) (taylor -inf x) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) z) (taylor 0 b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z)))))) (taylor 0 b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z)))))) (taylor 0 b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z)))))) (taylor 0 b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) z) (taylor inf b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* 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)))))))) (taylor inf b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* 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)))))))) (taylor inf b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* 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)))))))) (taylor inf b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) z) (taylor -inf b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b))))) (taylor -inf b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b))))) (taylor -inf b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b))))) (taylor -inf b) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z) (taylor inf c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z) (taylor inf c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z) (taylor inf c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z) (taylor inf c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z) (taylor -inf c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z) (taylor -inf c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z) (taylor -inf c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z) (taylor -inf c) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z) (taylor 0 t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ t z) (taylor inf t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z))))))) (taylor inf t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z))))))) (taylor inf t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z))))))) (taylor inf t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ t z) (taylor -inf t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z)))) (taylor -inf t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z)))) (taylor -inf t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z)))) (taylor -inf t) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z) (taylor 0 a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))) (taylor 0 a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ a z) (taylor inf a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ a z) (taylor -inf a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z)))) (taylor -inf a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z)))) (taylor -inf a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z)))) (taylor -inf a) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor 0 z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor inf z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor inf z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor inf z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor inf z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor -inf z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor -inf z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor -inf z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z) (taylor -inf z) (#s(alt (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) (patch (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) a) (taylor inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y))))))) (taylor inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y))))))) (taylor inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y))))))) (taylor inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) a) (taylor -inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y))))) (taylor -inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y))))) (taylor -inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y))))) (taylor -inf y) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) a) (taylor inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i))))))) (taylor inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i))))))) (taylor inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i))))))) (taylor inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) a) (taylor -inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i))))) (taylor -inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i))))) (taylor -inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i))))) (taylor -inf i) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor -inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a) (taylor 0 x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) a) (taylor inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))) (taylor inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))) (taylor inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))) (taylor inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) a) (taylor -inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x))))) (taylor -inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x))))) (taylor -inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x))))) (taylor -inf x) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) a) (taylor 0 b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a)))))) (taylor 0 b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a)))))) (taylor 0 b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a)))))) (taylor 0 b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b)))))))) (taylor inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b)))))))) (taylor inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b)))))))) (taylor inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor -inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b))))) (taylor -inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b))))) (taylor -inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b))))) (taylor -inf b) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a) (taylor inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a) (taylor inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a) (taylor inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a) (taylor inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a) (taylor -inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a) (taylor -inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a) (taylor -inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a) (taylor -inf c) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))) (taylor inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))) (taylor inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))) (taylor inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor -inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor -inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor -inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor -inf a) (#s(alt (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (patch (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (patch (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor 0 x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (log y)) a)) (taylor 0 x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (log y)) a)) (taylor 0 x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (log y)) a)) (taylor 0 x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) a) (taylor inf x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ z (* a x)) (/ (log y) a))) (taylor inf x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ z (* a x)) (/ (log y) a))) (taylor inf x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ z (* a x)) (/ (log y) a))) (taylor inf x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) a) (taylor -inf x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ z (* a x))) (* -1 (/ (log y) a))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ z (* a x))) (* -1 (/ (log y) a))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ z (* a x))) (* -1 (/ (log y) a))))) (taylor -inf x) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* x (log y))) a) (taylor 0 a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* x (log y))) a) (taylor 0 a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* x (log y))) a) (taylor 0 a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* x (log y))) a) (taylor 0 a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* x (log y))) a) (taylor inf a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* x (log y))) a) (taylor inf a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* x (log y))) a) (taylor inf a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (* x (log y))) a) (taylor inf a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a)) (taylor -inf a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a)) (taylor -inf a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a)) (taylor -inf a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a)) (taylor -inf a) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (log y)) a)) (taylor 0 y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (log y)) a)) (taylor 0 y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (log y)) a)) (taylor 0 y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (log y)) a)) (taylor 0 y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a)) (taylor inf y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a)) (taylor inf y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a)) (taylor inf y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a)) (taylor inf y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a)) (taylor -inf y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a)) (taylor -inf y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a)) (taylor -inf y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a)) (taylor -inf y) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) a) (taylor 0 z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (log y)) a)) (taylor 0 z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (log y)) a)) (taylor 0 z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* x (log y)) a)) (taylor 0 z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor inf z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (/ (* x (log y)) (* a z)))) (taylor inf z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (/ (* x (log y)) (* a z)))) (taylor inf z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (/ (* x (log y)) (* a z)))) (taylor inf z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor -inf z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* x (log y)) (* a z))) (/ 1 a)))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* x (log y)) (* a z))) (/ 1 a)))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (* x (log y)) (* a z))) (/ 1 a)))) (taylor -inf z) (#s(alt (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (patch (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a)) (taylor inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a)) (taylor inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a)) (taylor inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a)) (taylor inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)) (taylor -inf c) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor 0 a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor inf a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor inf a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor inf a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor inf a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a)) (taylor -inf a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a)) (taylor -inf a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a)) (taylor -inf a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a)) (taylor -inf a) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (/ t a)) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a))) (taylor 0 b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a)))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a)))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a)))) (taylor inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b))))) (taylor -inf b) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* (log c) (- b 1/2)) a) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t)))) (taylor inf t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t)))) (taylor inf t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t)))) (taylor inf t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a)))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a)))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a)))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (patch (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor 0 i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (*.f64 y i) (patch (*.f64 y i) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1/2 (log c))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b)))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b)))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b)))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 (* (log (/ 1 c)) (- b 1/2)))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 (* (log (/ 1 c)) (- b 1/2)))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 (* (log (/ 1 c)) (- b 1/2)))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* -1 (* (log (/ 1 c)) (- b 1/2)))) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* (log c) (- b 1/2)) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ (* (log c) (- b 1/2)) t))) (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ (* (log c) (- b 1/2)) t))) (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ (* (log c) (- b 1/2)) t))) (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))) (taylor inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))) (taylor inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))) (taylor inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))) (taylor inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))) (taylor -inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))) (taylor -inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))) (taylor -inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))) (taylor -inf y) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (* (log c) (- b 1/2))) (taylor 0 x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) (taylor inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) (taylor inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x)))) (taylor inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x))))) (taylor -inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x))))) (taylor -inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x))))) (taylor -inf x) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (* x (log y)))) (taylor 0 b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))) (taylor 0 b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))) (taylor 0 b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y))))) (taylor 0 b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b))))) (taylor inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b))))) (taylor inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b))))) (taylor inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b))))) (taylor -inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b))))) (taylor -inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b))))) (taylor -inf b) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))) (taylor inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))) (taylor inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))) (taylor inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y)))) (taylor inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ (* x (log y)) (* (log c) (- b 1/2))) (taylor 0 t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))) (taylor 0 t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))) (taylor inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))) (taylor inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))) (taylor inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (patch (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #<representation binary64>) () ())) ())
Calls

426 calls:

TimeVariablePointExpression
28.0ms
x
@inf
(* (log y) x)
16.0ms
a
@0
(+ (+ (* (/ x a) (log y)) (/ z a)) (+ (* (/ (log c) a) (- b 1/2)) (/ t a)))
5.0ms
a
@inf
(+ (+ (* (/ x a) (log y)) (/ z a)) (+ (* (/ (log c) a) (- b 1/2)) (/ t a)))
2.0ms
a
@0
(+ (* (+ (+ (* (/ x a) (log y)) (/ z a)) (+ (* (/ (log c) a) (- b 1/2)) (/ t a))) a) a)
1.0ms
y
@-inf
(+ (* (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) a) a)

simplify295.0ms (2.2%)

Memory
53.7MiB live, 569.6MiB allocated
Algorithm
1×egg-herbie
Rules
8 130×lower-fma.f64
8 130×lower-fma.f32
6 732×lower-*.f64
6 732×lower-*.f32
5 894×lower-+.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
096334329
1330433882
0811931594
Stop Event
1×iter limit
1×node limit
Counts
1 704 → 1 624
Calls
Call 1
Inputs
(+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
z
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
z
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(* b (log c))
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
t
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
t
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(/ (* x (log y)) a)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(/ (* x (log y)) a)
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(/ z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(/ z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(/ (* b (log c)) a)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(/ (* b (log c)) a)
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(/ t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(/ t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(* i y)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
a
(+ a t)
(+ a t)
(+ a t)
t
(* t (+ 1 (/ a t)))
(* t (+ 1 (/ a t)))
(* t (+ 1 (/ a t)))
t
(* -1 (* t (- (* -1 (/ a t)) 1)))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(* -1 (* t (- (* -1 (/ a t)) 1)))
t
(+ a t)
(+ a t)
(+ a t)
a
(* a (+ 1 (/ t a)))
(* a (+ 1 (/ t a)))
(* a (+ 1 (/ t a)))
a
(* -1 (* a (- (* -1 (/ t a)) 1)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(+ z (+ (* -1/2 (log c)) (* i y)))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (* (log c) (- b 1/2)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(* i y)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(+ z (* (log c) (- b 1/2)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(* i y)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(+ (* i y) (* (log c) (- b 1/2)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
z
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
z
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(log y)
(log y)
(log y)
(log y)
(* -1 (log (/ 1 y)))
(* -1 (log (/ 1 y)))
(* -1 (log (/ 1 y)))
(* -1 (log (/ 1 y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(+ (log -1) (* -1 (log (/ -1 y))))
(+ (log -1) (* -1 (log (/ -1 y))))
(+ (log -1) (* -1 (log (/ -1 y))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(/ (* i y) z)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(/ (* i y) z)
(* -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)))))
(* -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)))))
(* -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)))))
(/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(/ (* i y) z)
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(/ (* i y) z)
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(/ (* x (log y)) z)
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(/ (* x (log y)) z)
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) z)
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(/ (* b (log c)) z)
(* 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))))))))
(* 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))))))))
(* 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))))))))
(/ (* b (log c)) z)
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(/ t z)
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(/ t z)
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(/ a z)
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(/ a z)
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(/ (* i y) a)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(/ (* i y) a)
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(/ (* i y) a)
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(/ (* i y) a)
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(/ z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(/ z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(/ (* x (log y)) a)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(/ (* x (log y)) a)
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) a)
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(/ (* b (log c)) a)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(/ (* b (log c)) a)
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(/ t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(/ t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* i y)
(* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
z
(* z (+ 1 (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
z
(* -1 (* z (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))
(+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(/ z a)
(+ (/ z a) (/ (* x (log y)) a))
(+ (/ z a) (/ (* x (log y)) a))
(+ (/ z a) (/ (* x (log y)) a))
(/ (* x (log y)) a)
(* x (+ (/ z (* a x)) (/ (log y) a)))
(* x (+ (/ z (* a x)) (/ (log y) a)))
(* x (+ (/ z (* a x)) (/ (log y) a)))
(/ (* x (log y)) a)
(* -1 (* x (+ (* -1 (/ z (* a x))) (* -1 (/ (log y) a)))))
(* -1 (* x (+ (* -1 (/ z (* a x))) (* -1 (/ (log y) a)))))
(* -1 (* x (+ (* -1 (/ z (* a x))) (* -1 (/ (log y) a)))))
(/ (+ z (* x (log y))) a)
(/ (+ z (* x (log y))) a)
(/ (+ z (* x (log y))) a)
(/ (+ z (* x (log y))) a)
(/ (+ z (* x (log y))) a)
(/ (+ z (* x (log y))) a)
(/ (+ z (* x (log y))) a)
(/ (+ z (* x (log y))) a)
(* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a))
(* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a))
(* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a))
(* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a))
(+ (/ z a) (/ (* x (log y)) a))
(+ (/ z a) (/ (* x (log y)) a))
(+ (/ z a) (/ (* x (log y)) a))
(+ (/ z a) (/ (* x (log y)) a))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a))
(+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a))
(+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a))
(+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a))
(+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a))
(/ (* x (log y)) a)
(+ (/ z a) (/ (* x (log y)) a))
(+ (/ z a) (/ (* x (log y)) a))
(+ (/ z a) (/ (* x (log y)) a))
(/ z a)
(* z (+ (/ 1 a) (/ (* x (log y)) (* a z))))
(* z (+ (/ 1 a) (/ (* x (log y)) (* a z))))
(* z (+ (/ 1 a) (/ (* x (log y)) (* a z))))
(/ z a)
(* -1 (* z (- (* -1 (/ (* x (log y)) (* a z))) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (* x (log y)) (* a z))) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (* x (log y)) (* a z))) (/ 1 a))))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(+ (* -1/2 (/ (log c) a)) (/ t a))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(/ (* b (log c)) a)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(/ (* b (log c)) a)
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(/ (* (log c) (- b 1/2)) a)
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(/ t a)
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(/ t a)
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(* i y)
(+ t (* -1/2 (log c)))
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(+ t (* (log c) (- b 1/2)))
(+ t (* (log c) (- b 1/2)))
(+ t (* (log c) (- b 1/2)))
(+ t (* (log c) (- b 1/2)))
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(* (log c) (- b 1/2))
(+ t (* (log c) (- b 1/2)))
(+ t (* (log c) (- b 1/2)))
(+ t (* (log c) (- b 1/2)))
t
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
t
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+ t (* (log c) (- b 1/2)))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(* x (log y))
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(+ t (+ (* -1/2 (log c)) (* x (log y))))
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ (* x (log y)) (* (log c) (- b 1/2)))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
t
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
t
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
Outputs
(+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))
(fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(+.f64 (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a (*.f64 (log.f64 y) x)) a)
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(+.f64 (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a (*.f64 (log.f64 y) x)) a)
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(+.f64 (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a (*.f64 (log.f64 y) x)) a)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(*.f64 (+.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) x) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(*.f64 (+.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) x) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(*.f64 (+.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) x) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a a) (neg.f64 x)) (log.f64 y)))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))) #s(literal 1 binary64)))
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))) #s(literal 1 binary64)))
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))) #s(literal 1 binary64)))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) a a)
(+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) a a)
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) a z) a)
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) a z) a)
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) a z) a)
z
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
(fma.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) z) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
(fma.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) z) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
(fma.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) z) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(*.f64 (neg.f64 z) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) a a) (neg.f64 z)) #s(literal 1 binary64)))
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(*.f64 (neg.f64 z) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) a a) (neg.f64 z)) #s(literal 1 binary64)))
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(*.f64 (neg.f64 z) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) a a) (neg.f64 z)) #s(literal 1 binary64)))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(fma.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(fma.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(fma.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(fma.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(+.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a (*.f64 b (log.f64 c))) a)
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(+.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a (*.f64 b (log.f64 c))) a)
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(+.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a (*.f64 b (log.f64 c))) a)
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(*.f64 (+.f64 (fma.f64 a (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) b) (/.f64 a b)) (log.f64 c)) b)
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(*.f64 (+.f64 (fma.f64 a (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) b) (/.f64 a b)) (log.f64 c)) b)
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(*.f64 (+.f64 (fma.f64 a (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) b) (/.f64 a b)) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a) (neg.f64 b)) (log.f64 c)))
(+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) a a)
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) a t) a)
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) a t) a)
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) a t) a)
t
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
(fma.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) t) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
(fma.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) t) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
(fma.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) t) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) a a) (neg.f64 t)) #s(literal 1 binary64)))
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) a a) (neg.f64 t)) #s(literal 1 binary64)))
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) a a) (neg.f64 t)) #s(literal 1 binary64)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 a z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)))))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(/ (* x (log y)) a)
(/.f64 (*.f64 (log.f64 y) x) a)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 x a)) (/.f64 z (*.f64 x a))) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (/.f64 (log.f64 y) a))) x)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 x a)) (/.f64 z (*.f64 x a))) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (/.f64 (log.f64 y) a))) x)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 x a)) (/.f64 z (*.f64 x a))) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (/.f64 (log.f64 y) a))) x)
(/ (* x (log y)) a)
(/.f64 (*.f64 (log.f64 y) x) a)
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(/.f64 (neg.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(/.f64 (neg.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(/.f64 (neg.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(/.f64 (neg.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))) (neg.f64 a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))))
(+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(/ z a)
(/.f64 z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 t (*.f64 z a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z a)))) z)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 t (*.f64 z a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z a)))) z)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 t (*.f64 z a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z a)))) z)
(/ z a)
(/.f64 z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 t a)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 b (/.f64 (log.f64 c) a))) (/.f64 z a)) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 b (/.f64 (log.f64 c) a))) (/.f64 z a)) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 b (/.f64 (log.f64 c) a))) (/.f64 z a)) (/.f64 t a)))
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 t (*.f64 b a)) (/.f64 z (*.f64 b a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 b a)) (/.f64 (log.f64 c) a)))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 t (*.f64 b a)) (/.f64 z (*.f64 b a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 b a)) (/.f64 (log.f64 c) a)))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 t (*.f64 b a)) (/.f64 z (*.f64 b a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 b a)) (/.f64 (log.f64 c) a)))) b)
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a))
(/ t a)
(/.f64 t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 z (*.f64 t a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 t a)))) t)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 z (*.f64 t a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 t a)))) t)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 z (*.f64 t a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 t a)))) t)
(/ t a)
(/.f64 t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y)))))
(+.f64 (+.f64 (+.f64 (fma.f64 i y (*.f64 #s(literal -1/2 binary64) (log.f64 c))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i y (*.f64 #s(literal -1/2 binary64) (log.f64 c))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i y (*.f64 #s(literal -1/2 binary64) (log.f64 c))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i y (*.f64 #s(literal -1/2 binary64) (log.f64 c))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(* i y)
(*.f64 i y)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y))) y)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y))) y)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) y) i)) (neg.f64 y))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) i) y)) (neg.f64 i))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 z)) z (neg.f64 z)))
a
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
t
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
t
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (-.f64 (/.f64 a (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (-.f64 (/.f64 a (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (-.f64 (/.f64 a (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
t
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
a
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
a
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
(+ z (+ (* -1/2 (log c)) (* i y)))
(+.f64 (fma.f64 i y (*.f64 #s(literal -1/2 binary64) (log.f64 c))) z)
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 i (/.f64 y b) (/.f64 z b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 i (/.f64 y b) (/.f64 z b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 i (/.f64 y b) (/.f64 z b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 i y (*.f64 #s(literal -1/2 binary64) (log.f64 c))) z) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 i y (*.f64 #s(literal -1/2 binary64) (log.f64 c))) z) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 i y (*.f64 #s(literal -1/2 binary64) (log.f64 c))) z) (neg.f64 b)) (log.f64 c)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z)
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z)
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z)
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 i y)) z)
(+ z (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(* i y)
(*.f64 i y)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) i) y)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) i) y)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) i) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) y) i)) (neg.f64 y))
(+ z (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (/.f64 z i)) y) i)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (/.f64 z i)) y) i)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (/.f64 z i)) y) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) i) y)) (neg.f64 i))
(+ (* i y) (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))
z
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(fma.f64 (fma.f64 i (/.f64 y z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) z z)
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(fma.f64 (fma.f64 i (/.f64 y z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) z z)
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(fma.f64 (fma.f64 i (/.f64 y z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) z z)
z
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (log.f64 y) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(log y)
(log.f64 y)
(log y)
(log.f64 y)
(log y)
(log.f64 y)
(log y)
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(* -1 (log (/ 1 y)))
(log.f64 y)
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(+ (log -1) (* -1 (log (/ -1 y))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(/ (* i y) z)
(/.f64 (*.f64 i y) z)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 y) x) (*.f64 y z)) (/.f64 a (*.f64 y z))) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y z)) (/.f64 t (*.f64 y z))) (/.f64 i z))) y)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 y) x) (*.f64 y z)) (/.f64 a (*.f64 y z))) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y z)) (/.f64 t (*.f64 y z))) (/.f64 i z))) y)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* y z))) (+ (/ a (* y z)) (+ (/ i z) (+ (/ t (* y z)) (/ (* (log c) (- b 1/2)) (* y z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 y) x) (*.f64 y z)) (/.f64 a (*.f64 y z))) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y z)) (/.f64 t (*.f64 y z))) (/.f64 i z))) y)
(/ (* i y) z)
(/.f64 (*.f64 i y) z)
(* -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)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 a z) (/.f64 t z)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (neg.f64 y)) (/.f64 i z)) (neg.f64 y))
(* -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)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 a z) (/.f64 t z)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (neg.f64 y)) (/.f64 i z)) (neg.f64 y))
(* -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)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 a z) (/.f64 t z)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (neg.f64 y)) (/.f64 i z)) (neg.f64 y))
(/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(/ (* i y) z)
(/.f64 (*.f64 i y) z)
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 a (*.f64 i z)) (/.f64 t (*.f64 i z))) (+.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 i z)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 i z))) (/.f64 y z))) i)
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 a (*.f64 i z)) (/.f64 t (*.f64 i z))) (+.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 i z)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 i z))) (/.f64 y z))) i)
(* i (+ (/ a (* i z)) (+ (/ t (* i z)) (+ (/ y z) (+ (/ (* x (log y)) (* i z)) (/ (* (log c) (- b 1/2)) (* i z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 a (*.f64 i z)) (/.f64 t (*.f64 i z))) (+.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 i z)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 i z))) (/.f64 y z))) i)
(/ (* i y) z)
(/.f64 (*.f64 i y) z)
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) (neg.f64 i)) (/.f64 y z)) (neg.f64 i))
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) (neg.f64 i)) (/.f64 y z)) (neg.f64 i))
(* -1 (* i (+ (* -1 (/ y z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) (neg.f64 i)) (/.f64 y z)) (neg.f64 i))
(/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(/ (* x (log y)) z)
(/.f64 (*.f64 (log.f64 y) x) z)
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 x z)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 x z))) (/.f64 (log.f64 y) z)) (/.f64 t (*.f64 x z))) (/.f64 a (*.f64 x z))) x)
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 x z)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 x z))) (/.f64 (log.f64 y) z)) (/.f64 t (*.f64 x z))) (/.f64 a (*.f64 x z))) x)
(* x (+ (/ a (* x z)) (+ (/ t (* x z)) (+ (/ (log y) z) (+ (/ (* i y) (* x z)) (/ (* (log c) (- b 1/2)) (* x z)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 x z)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 x z))) (/.f64 (log.f64 y) z)) (/.f64 t (*.f64 x z))) (/.f64 a (*.f64 x z))) x)
(/ (* x (log y)) z)
(/.f64 (*.f64 (log.f64 y) x) z)
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) (neg.f64 x)) (/.f64 (log.f64 y) z)))
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) (neg.f64 x)) (/.f64 (log.f64 y) z)))
(* -1 (* x (+ (* -1 (/ (log y) z)) (* -1 (/ (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z))) (/.f64 t z)) (/.f64 a z)) (neg.f64 x)) (/.f64 (log.f64 y) z)))
(/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) z)
(/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) z)
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 b (/.f64 (log.f64 c) z) (fma.f64 i (/.f64 y z) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)))
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 b (/.f64 (log.f64 c) z) (fma.f64 i (/.f64 y z) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)))
(+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* b (log c)) z) (+ (/ (* i y) z) (/ (* x (log y)) z))))))
(fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 b (/.f64 (log.f64 c) z) (fma.f64 i (/.f64 y z) (/.f64 (*.f64 (log.f64 y) x) z))) (/.f64 t z)) (/.f64 a z)))
(/ (* b (log c)) z)
(*.f64 b (/.f64 (log.f64 c) z))
(* 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))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b z)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 b z)) (/.f64 (*.f64 (log.f64 y) x) (*.f64 b z))) (/.f64 (log.f64 c) z)) (/.f64 t (*.f64 b z))) (/.f64 a (*.f64 b z)))) b)
(* 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))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b z)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 b z)) (/.f64 (*.f64 (log.f64 y) x) (*.f64 b z))) (/.f64 (log.f64 c) z)) (/.f64 t (*.f64 b z))) (/.f64 a (*.f64 b z)))) b)
(* 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))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b z)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 b z)) (/.f64 (*.f64 (log.f64 y) x) (*.f64 b z))) (/.f64 (log.f64 c) z)) (/.f64 t (*.f64 b z))) (/.f64 a (*.f64 b z)))) b)
(/ (* b (log c)) z)
(*.f64 b (/.f64 (log.f64 c) z))
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z))) (neg.f64 b)) (/.f64 (log.f64 c) z)))
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z))) (neg.f64 b)) (/.f64 (log.f64 c) z)))
(* -1 (* b (+ (* -1 (/ (log c) z)) (* -1 (/ (+ (* -1/2 (/ (log c) z)) (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* x (log y)) z))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) z) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (/.f64 (*.f64 (log.f64 y) x) z)) (/.f64 t z)) (/.f64 a z))) (neg.f64 b)) (/.f64 (log.f64 c) z)))
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/.f64 (+.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)) (*.f64 (log.f64 y) x))) t) a) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/.f64 (+.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)) (*.f64 (log.f64 y) x))) t) a) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/.f64 (+.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)) (*.f64 (log.f64 y) x))) t) a) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) z)
(/.f64 (+.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)) (*.f64 (log.f64 y) x))) t) a) z)
(/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) a) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(/ t z)
(/.f64 t z)
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 a (*.f64 z t))) (fma.f64 i (/.f64 y (*.f64 z t)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z t)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z t))))) t)
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 a (*.f64 z t))) (fma.f64 i (/.f64 y (*.f64 z t)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z t)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z t))))) t)
(* t (+ (/ 1 z) (+ (/ a (* t z)) (+ (/ (* i y) (* t z)) (+ (/ (* x (log y)) (* t z)) (/ (* (log c) (- b 1/2)) (* t z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 a (*.f64 z t))) (fma.f64 i (/.f64 y (*.f64 z t)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z t)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z t))))) t)
(/ t z)
(/.f64 t z)
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 a z)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) z)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 a z)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) z)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ a z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) t)) (/ 1 z))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 a z)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) z)) (neg.f64 t))
(/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y (*.f64 (log.f64 y) x))) z)
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z))
(/ a z)
(/.f64 a z)
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 t (*.f64 z a))) (fma.f64 i (/.f64 y (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z a))))) a)
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 t (*.f64 z a))) (fma.f64 i (/.f64 y (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z a))))) a)
(* a (+ (/ 1 z) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) z) (/.f64 t (*.f64 z a))) (fma.f64 i (/.f64 y (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z a))))) a)
(/ a z)
(/.f64 a z)
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (neg.f64 a)) (/.f64 #s(literal 1 binary64) z)))
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (neg.f64 a)) (/.f64 #s(literal 1 binary64) z)))
(* -1 (* a (- (* -1 (/ (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))) a)) (/ 1 z))))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (neg.f64 a)) (/.f64 #s(literal 1 binary64) z)))
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)
(/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) z)
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 y)) i) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 y)) i) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 y)) i) (neg.f64 y))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a)
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.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)) (*.f64 (log.f64 y) x))) t) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.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)) (*.f64 (log.f64 y) x))) t) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.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)) (*.f64 (log.f64 y) x))) t) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.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)) (*.f64 (log.f64 y) x))) t) a)
(+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
t
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) a) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y (*.f64 (log.f64 y) x)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
a
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y (*.f64 (log.f64 y) x))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y (*.f64 (log.f64 y) x))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y (*.f64 (log.f64 y) x))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)) (/.f64 a y))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 a z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 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)) (*.f64 (log.f64 y) x))) z))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (+.f64 (fma.f64 (log.f64 y) x z) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(/ (* i y) a)
(/.f64 (*.f64 i y) a)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(*.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 y) x) (*.f64 y a)) (/.f64 i a)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y a)) (/.f64 z (*.f64 y a))) (/.f64 t (*.f64 y a)))) y)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(*.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 y) x) (*.f64 y a)) (/.f64 i a)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y a)) (/.f64 z (*.f64 y a))) (/.f64 t (*.f64 y a)))) y)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(*.f64 (+.f64 (+.f64 (/.f64 (*.f64 (log.f64 y) x) (*.f64 y a)) (/.f64 i a)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y a)) (/.f64 z (*.f64 y a))) (/.f64 t (*.f64 y a)))) y)
(/ (* i y) a)
(/.f64 (*.f64 i y) a)
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (neg.f64 y)) (/.f64 i a)) (neg.f64 y))
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (neg.f64 y)) (/.f64 i a)) (neg.f64 y))
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 t a) (/.f64 z a)) (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (neg.f64 y)) (/.f64 i a)) (neg.f64 y))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(/ (* i y) a)
(/.f64 (*.f64 i y) a)
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 i a)) (/.f64 y a)) (+.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 i a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 i a))) (/.f64 z (*.f64 i a)))) i)
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 i a)) (/.f64 y a)) (+.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 i a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 i a))) (/.f64 z (*.f64 i a)))) i)
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 i a)) (/.f64 y a)) (+.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 i a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 i a))) (/.f64 z (*.f64 i a)))) i)
(/ (* i y) a)
(/.f64 (*.f64 i y) a)
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) (neg.f64 i)) (/.f64 y a)) (neg.f64 i))
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) (neg.f64 i)) (/.f64 y a)) (neg.f64 i))
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) (neg.f64 i)) (/.f64 y a)) (neg.f64 i))
(/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y (*.f64 (log.f64 y) x))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(/ z a)
(/.f64 z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 t (*.f64 z a))) (fma.f64 i (/.f64 y (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z a))))) z)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 t (*.f64 z a))) (fma.f64 i (/.f64 y (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z a))))) z)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 t (*.f64 z a))) (fma.f64 i (/.f64 y (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 z a))))) z)
(/ z a)
(/.f64 z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 t a)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 t a)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 t a)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(/ (* x (log y)) a)
(/.f64 (*.f64 (log.f64 y) x) a)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 x a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 x a))) (/.f64 (log.f64 y) a)) (/.f64 z (*.f64 x a))) (/.f64 t (*.f64 x a))) x)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 x a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 x a))) (/.f64 (log.f64 y) a)) (/.f64 z (*.f64 x a))) (/.f64 t (*.f64 x a))) x)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 x a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 x a))) (/.f64 (log.f64 y) a)) (/.f64 z (*.f64 x a))) (/.f64 t (*.f64 x a))) x)
(/ (* x (log y)) a)
(/.f64 (*.f64 (log.f64 y) x) a)
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a)) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) a)
(/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 b (/.f64 (log.f64 c) a) (fma.f64 i (/.f64 y a) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 b (/.f64 (log.f64 c) a) (fma.f64 i (/.f64 y a) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 b (/.f64 (log.f64 c) a) (fma.f64 i (/.f64 y a) (/.f64 (*.f64 (log.f64 y) x) a))) (/.f64 z a)) (/.f64 t a)))
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 b a)) (/.f64 (*.f64 (log.f64 y) x) (*.f64 b a))) (/.f64 (log.f64 c) a)) (/.f64 z (*.f64 b a))) (/.f64 t (*.f64 b a)))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 b a)) (/.f64 (*.f64 (log.f64 y) x) (*.f64 b a))) (/.f64 (log.f64 c) a)) (/.f64 z (*.f64 b a))) (/.f64 t (*.f64 b a)))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 b a)) (/.f64 (*.f64 (log.f64 y) x) (*.f64 b a))) (/.f64 (log.f64 c) a)) (/.f64 z (*.f64 b a))) (/.f64 t (*.f64 b a)))) b)
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y a) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a)) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (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)) (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (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)) (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (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)) (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (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)) (*.f64 (log.f64 y) x)))) a)
(/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (/.f64 t a))
(/ t a)
(/.f64 t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 z (*.f64 t a))) (fma.f64 i (/.f64 y (*.f64 t a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 t a))))) t)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 z (*.f64 t a))) (fma.f64 i (/.f64 y (*.f64 t a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 t a))))) t)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(*.f64 (+.f64 (+.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 z (*.f64 t a))) (fma.f64 i (/.f64 y (*.f64 t a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (*.f64 t a))))) t)
(/ t a)
(/.f64 t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a)))) (/.f64 z a)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 (*.f64 (log.f64 y) x) y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 y)) i) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 y)) i) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 y)) i) (neg.f64 y))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 t i)) (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i))) i)
(* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 t i)) (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i))) i)
(* i (+ y (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 t i)) (+.f64 (fma.f64 x (/.f64 (log.f64 y) i) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i))) (/.f64 z i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (neg.f64 i)) y) (neg.f64 i))
(+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y (*.f64 (log.f64 y) x)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
z
(* z (+ 1 (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) z z)
(* z (+ 1 (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) z z)
(* z (+ 1 (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y (*.f64 (log.f64 y) x))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y (*.f64 (log.f64 y) x))) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y (*.f64 (log.f64 y) x))) (neg.f64 z)) z (neg.f64 z)))
(+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y x) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x))) (/.f64 z x)) (/.f64 t x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))) (neg.f64 x)) (log.f64 y)))
(+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t)
(+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 (*.f64 (log.f64 y) x) b)) (/.f64 z b)) (/.f64 t b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) (neg.f64 b)) (log.f64 c)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t z) (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)) (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t z) (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)) (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t z) (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)) (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t z) (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)) (*.f64 (log.f64 y) x))))
(+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))))
t
(* t (+ 1 (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) t t)
(* t (+ 1 (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) t t)
(* t (+ 1 (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) (fma.f64 i y (*.f64 (log.f64 y) x))) (neg.f64 t)) t (neg.f64 t)))
(/ z a)
(/.f64 z a)
(+ (/ z a) (/ (* x (log y)) a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (/ z a) (/ (* x (log y)) a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (/ z a) (/ (* x (log y)) a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(/ (* x (log y)) a)
(/.f64 (*.f64 (log.f64 y) x) a)
(* x (+ (/ z (* a x)) (/ (log y) a)))
(*.f64 (+.f64 (/.f64 (log.f64 y) a) (/.f64 z (*.f64 x a))) x)
(* x (+ (/ z (* a x)) (/ (log y) a)))
(*.f64 (+.f64 (/.f64 (log.f64 y) a) (/.f64 z (*.f64 x a))) x)
(* x (+ (/ z (* a x)) (/ (log y) a)))
(*.f64 (+.f64 (/.f64 (log.f64 y) a) (/.f64 z (*.f64 x a))) x)
(/ (* x (log y)) a)
(/.f64 (*.f64 (log.f64 y) x) a)
(* -1 (* x (+ (* -1 (/ z (* a x))) (* -1 (/ (log y) a)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 z) (*.f64 x a)) (/.f64 (log.f64 y) a)))
(* -1 (* x (+ (* -1 (/ z (* a x))) (* -1 (/ (log y) a)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 z) (*.f64 x a)) (/.f64 (log.f64 y) a)))
(* -1 (* x (+ (* -1 (/ z (* a x))) (* -1 (/ (log y) a)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 z) (*.f64 x a)) (/.f64 (log.f64 y) a)))
(/ (+ z (* x (log y))) a)
(/.f64 (fma.f64 (log.f64 y) x z) a)
(/ (+ z (* x (log y))) a)
(/.f64 (fma.f64 (log.f64 y) x z) a)
(/ (+ z (* x (log y))) a)
(/.f64 (fma.f64 (log.f64 y) x z) a)
(/ (+ z (* x (log y))) a)
(/.f64 (fma.f64 (log.f64 y) x z) a)
(/ (+ z (* x (log y))) a)
(/.f64 (fma.f64 (log.f64 y) x z) a)
(/ (+ z (* x (log y))) a)
(/.f64 (fma.f64 (log.f64 y) x z) a)
(/ (+ z (* x (log y))) a)
(/.f64 (fma.f64 (log.f64 y) x z) a)
(/ (+ z (* x (log y))) a)
(/.f64 (fma.f64 (log.f64 y) x z) a)
(* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a))
(/.f64 (neg.f64 (fma.f64 (log.f64 y) x z)) (neg.f64 a))
(* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a))
(/.f64 (neg.f64 (fma.f64 (log.f64 y) x z)) (neg.f64 a))
(* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a))
(/.f64 (neg.f64 (fma.f64 (log.f64 y) x z)) (neg.f64 a))
(* -1 (/ (+ (* -1 z) (* -1 (* x (log y)))) a))
(/.f64 (neg.f64 (fma.f64 (log.f64 y) x z)) (neg.f64 a))
(+ (/ z a) (/ (* x (log y)) a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (/ z a) (/ (* x (log y)) a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (/ z a) (/ (* x (log y)) a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (/ z a) (/ (* x (log y)) a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (/ z a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a))
(fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (/.f64 z a))
(+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a))
(fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (/.f64 z a))
(+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a))
(fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (/.f64 z a))
(+ (/ z a) (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a))
(fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (/.f64 z a))
(/ (* x (log y)) a)
(/.f64 (*.f64 (log.f64 y) x) a)
(+ (/ z a) (/ (* x (log y)) a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (/ z a) (/ (* x (log y)) a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(+ (/ z a) (/ (* x (log y)) a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(/ z a)
(/.f64 z a)
(* z (+ (/ 1 a) (/ (* x (log y)) (* a z))))
(*.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 #s(literal 1 binary64) a)) z)
(* z (+ (/ 1 a) (/ (* x (log y)) (* a z))))
(*.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 #s(literal 1 binary64) a)) z)
(* z (+ (/ 1 a) (/ (* x (log y)) (* a z))))
(*.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 #s(literal 1 binary64) a)) z)
(/ z a)
(/.f64 z a)
(* -1 (* z (- (* -1 (/ (* x (log y)) (* a z))) (/ 1 a))))
(*.f64 (neg.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 #s(literal 1 binary64) a))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (* x (log y)) (* a z))) (/ 1 a))))
(*.f64 (neg.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 #s(literal 1 binary64) a))) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (* x (log y)) (* a z))) (/ 1 a))))
(*.f64 (neg.f64 (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 #s(literal 1 binary64) a))) (neg.f64 z))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(/.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(/.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(/.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(/.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (neg.f64 a))
(+ (* -1/2 (/ (log c) a)) (/ t a))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (/.f64 t a))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (fma.f64 b (/.f64 (log.f64 c) a) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (fma.f64 b (/.f64 (log.f64 c) a) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (fma.f64 b (/.f64 (log.f64 c) a) (/.f64 t a)))
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (/.f64 t (*.f64 b a)) (/.f64 (log.f64 c) a))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (/.f64 t (*.f64 b a)) (/.f64 (log.f64 c) a))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (/.f64 t (*.f64 b a)) (/.f64 (log.f64 c) a))) b)
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (/.f64 t a)) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (/.f64 t a)) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (/.f64 t a)) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(/ (* (log c) (- b 1/2)) a)
(*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(/ t a)
(/.f64 t a)
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a)) t)
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a)) t)
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a)) t)
(/ t a)
(/.f64 t a)
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(*.f64 (neg.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(*.f64 (neg.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(*.f64 (neg.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a))) (neg.f64 t))
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(* i y)
(*.f64 i y)
(+ t (* -1/2 (log c)))
(fma.f64 #s(literal -1/2 binary64) (log.f64 c) t)
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (+ (* -1/2 (log c)) (* b (log c))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (/.f64 t b)) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (/.f64 t b)) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (/ t b))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (/.f64 t b)) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) t) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) t) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (* -1/2 (log c))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) t) (neg.f64 b)) (log.f64 c)))
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* -1 (* (log (/ 1 c)) (- b 1/2))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) t)
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) t)
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) t)
(+ t (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) t)
(* (log c) (- b 1/2))
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
t
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
(fma.f64 (*.f64 t (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) t)
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
(fma.f64 (*.f64 t (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) t)
(* t (+ 1 (/ (* (log c) (- b 1/2)) t)))
(fma.f64 (*.f64 t (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) t)
t
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(*.f64 (fma.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(*.f64 (fma.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) #s(literal -1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) t)) 1)))
(*.f64 (fma.f64 (neg.f64 (log.f64 c)) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) #s(literal -1 binary64)) (neg.f64 t))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)
(+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)
(+ t (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 t x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 t x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ t x) (/ (* (log c) (- b 1/2)) x))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (/.f64 t x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) x) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) x) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ t (* (log c) (- b 1/2))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) x) (log.f64 y)))
(+ t (+ (* -1/2 (log c)) (* x (log y))))
(+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) t)
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (* x (log y)))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 t b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 t b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ t b) (/ (* x (log y)) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 t b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) t) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) t) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ t (+ (* -1/2 (log c)) (* x (log y)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (*.f64 (log.f64 y) x)) t) (neg.f64 b)) (log.f64 c)))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* x (log y))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t)
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t)
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t)
(+ t (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 y) x)) t)
(+ (* x (log y)) (* (log c) (- b 1/2)))
(fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+ t (+ (* x (log y)) (* (log c) (- b 1/2))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
t
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t))) t t)
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t))) t t)
(* t (+ 1 (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t))) t t)
t
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ (* x (log y)) (* (log c) (- b 1/2))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (log.f64 y) x (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (neg.f64 t)) t (neg.f64 t)))

rewrite223.0ms (1.7%)

Memory
2.0MiB live, 276.0MiB allocated
Rules
4 536×lower-fma.f32
4 520×lower-fma.f64
4 230×lower-*.f32
4 226×lower-*.f64
3 714×lower-pow.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
058504
089504
1437504
24392500
08721472
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
24 → 388
Calls
Call 1
Inputs
(fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a))
(+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
(+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))
(+.f64 t a)
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(log.f64 y)
(fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) 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)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z))
(/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
(fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a))
(/.f64 (+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+.f64 (fma.f64 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
(fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a))
(fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))
(*.f64 y i)
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
Outputs
(*.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) (+.f64 (/.f64 t a) #s(literal 1 binary64))) a)
(*.f64 (-.f64 (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a (neg.f64 a))))
(*.f64 (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 a (-.f64 a (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a)) (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64)))))
(*.f64 a (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) (+.f64 (/.f64 t a) #s(literal 1 binary64))))
(pow.f64 (/.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a (neg.f64 a)) (-.f64 (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64)) (*.f64 a a))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 a (-.f64 a (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a)) (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64))) (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64))) (-.f64 a (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64)) (*.f64 a a))) (neg.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a (neg.f64 a))))
(/.f64 (neg.f64 (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 3 binary64)))) (neg.f64 (fma.f64 a (-.f64 a (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a)) (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64)) (*.f64 a a)) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a (neg.f64 a)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a (neg.f64 a)) (-.f64 (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64)) (*.f64 a a))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 a (-.f64 a (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a)) (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64))) (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 3 binary64)))))
(/.f64 (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 3 binary64))) (fma.f64 a a (-.f64 (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64)) (*.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) a))))
(/.f64 (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 3 binary64))) (fma.f64 a (-.f64 a (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a)) (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64))))
(fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)
(fma.f64 a (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a)
(-.f64 (/.f64 (pow.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) #s(literal 2 binary64)) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a (neg.f64 a))) (/.f64 (*.f64 a a) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a (neg.f64 a))))
(+.f64 (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a) a)
(+.f64 a (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a))
(*.f64 (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y)) (/.f64 #s(literal 1 binary64) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) (*.f64 i y))))
(*.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) (*.f64 i y)) (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64))) (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64))) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y))) (neg.f64 (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) (*.f64 i y))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y)) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) (*.f64 i y)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) (*.f64 i y)) (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64)) (*.f64 (*.f64 (*.f64 i y) i) y))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64))) (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 3 binary64)))))
(/.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 i y) i) y (-.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64)) (*.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a))))))
(/.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 3 binary64))) (fma.f64 (*.f64 i y) (-.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a))) (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64))))
(fma.f64 i y #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)))
(-.f64 (/.f64 (pow.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) #s(literal 2 binary64)) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) (*.f64 i y))) (/.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (-.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) (*.f64 i y))))
(+.f64 (*.f64 i y) #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))) a a))
(*.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (log.f64 y) (/.f64 x a) (-.f64 (/.f64 z a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))))))
(*.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (fma.f64 (log.f64 y) (/.f64 x a) (-.f64 (/.f64 z a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)))) (-.f64 (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64))) (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) (/.f64 t a)))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (pow.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #s(literal 2 binary64))) (-.f64 (/.f64 (*.f64 (log.f64 y) x) a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 2 binary64)) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64))) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) #s(literal 3 binary64)) (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a))) (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) #s(literal 2 binary64)) (-.f64 (/.f64 (*.f64 t t) (*.f64 a a)) (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) (/.f64 t a)))))
(/.f64 (+.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64)) (pow.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #s(literal 3 binary64))) (+.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (-.f64 (pow.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #s(literal 2 binary64)) (*.f64 (/.f64 (*.f64 (log.f64 y) x) a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 2 binary64)))) (neg.f64 (fma.f64 (log.f64 y) (/.f64 x a) (-.f64 (/.f64 z a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a) (*.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a) (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a) (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a)))
(/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64))) (*.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a) (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64))))) (*.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a) (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 3 binary64))) (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a) (*.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64))) (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a))))) (*.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64))) (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a)))
(/.f64 (fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 3 binary64))) (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64))) (*.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64))))) (*.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64))) (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a))) (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a) (*.f64 (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a) (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))))) (*.f64 (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a) (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a)))
(/.f64 (fma.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a))) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64))) (*.f64 (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a) (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 3 binary64))))) (*.f64 (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64))) (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a) (*.f64 (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64))) (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))))) (*.f64 (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64))) (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a)))
(/.f64 (fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64))) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64))) (*.f64 (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 3 binary64))))) (*.f64 (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64))) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 2 binary64))) (fma.f64 (log.f64 y) (/.f64 x a) (-.f64 (/.f64 z a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) (/.f64 x a) (-.f64 (/.f64 z a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)))) (-.f64 (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64))) (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 3 binary64)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64)) (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 3 binary64)) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 3 binary64))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64))))
(fma.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)))
(fma.f64 (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a)) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))
(fma.f64 (/.f64 #s(literal 1 binary64) a) (pow.f64 (/.f64 #s(literal 1 binary64) z) #s(literal -1 binary64)) (fma.f64 (log.f64 y) (/.f64 x a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))))
(fma.f64 (/.f64 #s(literal 1 binary64) a) (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(fma.f64 (/.f64 #s(literal 1 binary64) a) t (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(fma.f64 (/.f64 #s(literal 1 binary64) a) z (fma.f64 (log.f64 y) (/.f64 x a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))))
(fma.f64 #s(literal 1 binary64) (/.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(fma.f64 #s(literal 1 binary64) (/.f64 z a) (fma.f64 (log.f64 y) (/.f64 x a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))))
(fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)))) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)))
(fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)))) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))
(fma.f64 (neg.f64 t) (/.f64 #s(literal 1 binary64) (neg.f64 a)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(fma.f64 (neg.f64 z) (/.f64 #s(literal 1 binary64) (neg.f64 a)) (fma.f64 (log.f64 y) (/.f64 x a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))))
(fma.f64 (*.f64 (log.f64 y) x) (/.f64 #s(literal 1 binary64) a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)))
(fma.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (/.f64 #s(literal 1 binary64) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(fma.f64 t (/.f64 #s(literal 1 binary64) a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(fma.f64 (log.f64 c) (*.f64 (/.f64 #s(literal 1 binary64) a) (-.f64 b #s(literal 1/2 binary64))) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(fma.f64 z (/.f64 #s(literal 1 binary64) a) (fma.f64 (log.f64 y) (/.f64 x a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))))
(fma.f64 (log.f64 y) (/.f64 x a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)))
(fma.f64 (/.f64 x a) (log.f64 y) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)))
(fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)))
(-.f64 (/.f64 (pow.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) #s(literal 2 binary64)) (fma.f64 (log.f64 y) (/.f64 x a) (-.f64 (/.f64 z a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))))) (/.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #s(literal 2 binary64)) (fma.f64 (log.f64 y) (/.f64 x a) (-.f64 (/.f64 z a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 (*.f64 (log.f64 y) x) a)) (/.f64 z a))
(+.f64 (+.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) (/.f64 t a)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (/.f64 (*.f64 (log.f64 y) x) a))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))) (/.f64 t a))
(+.f64 (/.f64 (*.f64 (log.f64 y) x) a) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)))
(+.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) (+.f64 (/.f64 t a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)))
(+.f64 (/.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))))
(+.f64 (fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)))
(+.f64 (/.f64 z a) (fma.f64 (log.f64 y) (/.f64 x a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)))
(*.f64 (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))) (/.f64 #s(literal 1 binary64) (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))))
(*.f64 (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a)))))
(pow.f64 (/.f64 (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) (*.f64 (+.f64 t a) (+.f64 t a))) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)))
(/.f64 (-.f64 (*.f64 t t) (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) a) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) a))) (-.f64 t (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) a)))
(/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) a) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) a)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) a))) (fma.f64 t t (-.f64 (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) a) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) a)) (*.f64 t (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) a)))))
(/.f64 (neg.f64 (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))) (neg.f64 (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))))
(/.f64 (neg.f64 (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a)))) (neg.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a)))))
(/.f64 (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))) (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a)))))
(/.f64 (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))) (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)))))
(/.f64 (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))) (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))))
(fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))
(fma.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (/.f64 #s(literal 1 binary64) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))
(-.f64 (/.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))) (/.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) (-.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))))
(+.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) t) a)
(+.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) a) t)
(+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a))
(+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))
(+.f64 t (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) a))
(+.f64 a (+.f64 t #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
(*.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)))
(*.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (/.f64 #s(literal 1 binary64) (fma.f64 a (-.f64 a t) (*.f64 t t))))
(pow.f64 (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 a (-.f64 a t) (*.f64 t t)) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 a a) (*.f64 t t)) (-.f64 a t))
(/.f64 (neg.f64 (*.f64 (+.f64 t a) (-.f64 t a))) (neg.f64 (-.f64 t a)))
(/.f64 (neg.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a))) (neg.f64 (fma.f64 a (-.f64 a t) (*.f64 t t))))
(/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 a (-.f64 a t) (*.f64 t t)) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a))))
(/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a a (-.f64 (*.f64 t t) (*.f64 t a))))
(/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t)))
(-.f64 (/.f64 (*.f64 t t) (-.f64 t a)) (/.f64 (*.f64 a a) (-.f64 t a)))
(+.f64 t a)
(+.f64 a t)
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(*.f64 x (log.f64 y))
(log.f64 y)
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)) z)
(*.f64 (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) #s(literal 1 binary64) (neg.f64 (*.f64 z z))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) (neg.f64 z))))
(*.f64 (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 z z) z)) (/.f64 #s(literal 1 binary64) (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 z (-.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64)))))))
(*.f64 z (+.f64 #s(literal 1 binary64) (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)))
(pow.f64 (/.f64 (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) (neg.f64 z)) (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) #s(literal 1 binary64) (neg.f64 (*.f64 z z)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 z (-.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64))))) (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 z z) z))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 z z) (pow.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64)) #s(literal 2 binary64))) (-.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) #s(literal 1 binary64) (neg.f64 (*.f64 z z)))) (neg.f64 (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) (neg.f64 z))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 z z) z))) (neg.f64 (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 z (-.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64)))))))
(/.f64 (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) #s(literal 1 binary64) (neg.f64 (*.f64 z z))) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) (neg.f64 z)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) (neg.f64 z)) (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) #s(literal 1 binary64) (neg.f64 (*.f64 z z)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 z (-.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64))))) (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 z z) z))))
(/.f64 (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 z z) z)) (fma.f64 z z (-.f64 (pow.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64)) z))))
(/.f64 (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 z z) z)) (fma.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 z (-.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64))))))
(fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)
(fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z z)
(fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (/.f64 z z) z)
(fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)
(fma.f64 z (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z)
(-.f64 (/.f64 (pow.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64)) #s(literal 2 binary64)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) (neg.f64 z))) (/.f64 (*.f64 z z) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) (neg.f64 z))))
(+.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64)) z)
(+.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
(*.f64 (/.f64 #s(literal 1 binary64) z) (pow.f64 (/.f64 #s(literal 1 binary64) #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) z) #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)))
(*.f64 #s(literal 1 binary64) (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
(*.f64 (neg.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (/.f64 #s(literal 1 binary64) (neg.f64 z)))
(*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (/.f64 #s(literal 1 binary64) z))
(pow.f64 (/.f64 (/.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) #s(literal -1 binary64))
(/.f64 (neg.f64 (neg.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)))) (neg.f64 (neg.f64 z)))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))))
(/.f64 (neg.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (neg.f64 z))
(/.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64)) z)
(/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
(neg.f64 (/.f64 (neg.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) z))
(neg.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (neg.f64 z)))
(exp.f64 (*.f64 (log.f64 (/.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)))) #s(literal -1 binary64)))
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
(*.f64 (+.f64 #s(literal 1 binary64) (/.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) a)) a)
(*.f64 (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 2 binary64)) #s(literal 1 binary64) (neg.f64 (*.f64 a a))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64) (neg.f64 a))))
(*.f64 (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 a a) a)) (/.f64 #s(literal 1 binary64) (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 a (-.f64 a (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64)))))))
(*.f64 a (+.f64 #s(literal 1 binary64) (/.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) a)))
(pow.f64 (/.f64 (fma.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64) (neg.f64 a)) (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 2 binary64)) #s(literal 1 binary64) (neg.f64 (*.f64 a a)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 a (-.f64 a (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64))))) (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 a a) a))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64)) #s(literal 2 binary64))) (-.f64 a (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 2 binary64)) #s(literal 1 binary64) (neg.f64 (*.f64 a a)))) (neg.f64 (fma.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64) (neg.f64 a))))
(/.f64 (neg.f64 (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 a a) a))) (neg.f64 (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 a (-.f64 a (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64)))))))
(/.f64 (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 2 binary64)) #s(literal 1 binary64) (neg.f64 (*.f64 a a))) (fma.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64) (neg.f64 a)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64) (neg.f64 a)) (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 2 binary64)) #s(literal 1 binary64) (neg.f64 (*.f64 a a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 a (-.f64 a (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64))))) (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 a a) a))))
(/.f64 (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 a a) a)) (fma.f64 a a (-.f64 (pow.f64 (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (*.f64 (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64)) a))))
(/.f64 (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 3 binary64)) #s(literal 1 binary64) (*.f64 (*.f64 a a) a)) (fma.f64 (pow.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 2 binary64)) #s(literal 1 binary64) (*.f64 a (-.f64 a (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64))))))
(fma.f64 (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) a) (/.f64 #s(literal 1 binary64) a) a)
(fma.f64 (/.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) a) a a)
(fma.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) (/.f64 a a) a)
(fma.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64) a)
(fma.f64 a (/.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) a) a)
(-.f64 (/.f64 (pow.f64 (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64)) #s(literal 2 binary64)) (fma.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64) (neg.f64 a))) (/.f64 (*.f64 a a) (fma.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64) (neg.f64 a))))
(+.f64 (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64)) a)
(+.f64 a (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64) a))
(*.f64 (pow.f64 (/.f64 a (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 i y (-.f64 z (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))))
(*.f64 (pow.f64 (/.f64 a (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 3 binary64)))) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z)) (*.f64 (fma.f64 i y z) (fma.f64 i y z)))))
(*.f64 (/.f64 #s(literal 1 binary64) a) (pow.f64 (/.f64 #s(literal 1 binary64) (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z))) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) a) (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)))
(*.f64 #s(literal 1 binary64) (/.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) a))
(*.f64 (neg.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z))) (/.f64 #s(literal 1 binary64) (neg.f64 a)))
(*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) (/.f64 #s(literal 1 binary64) a))
(pow.f64 (/.f64 (/.f64 a (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z))) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 a (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z))) #s(literal -1 binary64))
(/.f64 (*.f64 (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) a)) (fma.f64 i y (-.f64 z (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))))
(/.f64 (*.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) a)) (fma.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))))
(/.f64 (neg.f64 (neg.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)))) (neg.f64 (neg.f64 a)))
(/.f64 (*.f64 (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 i y (-.f64 z (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))) a))
(/.f64 (*.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 3 binary64))) #s(literal 1 binary64)) (*.f64 (fma.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))) a))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 a (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)))))
(/.f64 (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64))) (*.f64 a (fma.f64 i y (-.f64 z (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 a (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z))) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 a (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z))))
(/.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 3 binary64))) (*.f64 a (fma.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z)) (*.f64 (fma.f64 i y z) (fma.f64 i y z)))))
(/.f64 (neg.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z))) (neg.f64 a))
(/.f64 (*.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) #s(literal 1 binary64)) a)
(/.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) a)
(neg.f64 (/.f64 (neg.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z))) a))
(neg.f64 (/.f64 (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)) (neg.f64 a)))
(exp.f64 (*.f64 (log.f64 (/.f64 a (fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)))) #s(literal -1 binary64)))
(*.f64 (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 i y (-.f64 z (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))))
(*.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z)) (*.f64 (fma.f64 i y z) (fma.f64 i y z)))))
(pow.f64 (/.f64 (fma.f64 i y (-.f64 z (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))) (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))) (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64))) (-.f64 (fma.f64 i y (fma.f64 (log.f64 y) x z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z)))
(/.f64 (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) #s(literal 2 binary64))) (-.f64 (*.f64 i y) (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)))
(/.f64 (+.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x z)) #s(literal 3 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 i y (fma.f64 (log.f64 y) x z)) #s(literal 2 binary64)) (-.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64)) (*.f64 (fma.f64 i y (fma.f64 (log.f64 y) x z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))))
(/.f64 (fma.f64 (*.f64 (*.f64 i i) i) (*.f64 (*.f64 y y) y) (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 i y) i) y (-.f64 (pow.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) #s(literal 2 binary64)) (*.f64 (*.f64 i y) (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)))))
(/.f64 (neg.f64 (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64)))) (neg.f64 (fma.f64 i y (-.f64 z (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z)) (*.f64 (fma.f64 i y z) (fma.f64 i y z)))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64))) (fma.f64 i y (neg.f64 z)) (*.f64 (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (*.f64 (fma.f64 i y z) (fma.f64 i y (neg.f64 z))))) (*.f64 (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y (neg.f64 z))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64))) (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 z (-.f64 z (*.f64 i y)))) (*.f64 (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 i y) (*.f64 (*.f64 z z) z)))) (*.f64 (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 z (-.f64 z (*.f64 i y))))))
(/.f64 (fma.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 i y (neg.f64 z)) (*.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (*.f64 (fma.f64 i y z) (fma.f64 i y (neg.f64 z))))) (*.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 i y (neg.f64 z))))
(/.f64 (fma.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 z (-.f64 z (*.f64 i y)))) (*.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 i y) (*.f64 (*.f64 z z) z)))) (*.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 z (-.f64 z (*.f64 i y))))))
(/.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y (neg.f64 z))) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (*.f64 (fma.f64 i y (neg.f64 z)) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64))))) (*.f64 (fma.f64 i y (neg.f64 z)) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))
(/.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y (neg.f64 z))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (*.f64 (fma.f64 i y (neg.f64 z)) (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))))) (*.f64 (fma.f64 i y (neg.f64 z)) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (fma.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 i y) (*.f64 (*.f64 z z) z)) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (*.f64 (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 z (-.f64 z (*.f64 i y)))) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64))))) (*.f64 (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 z (-.f64 z (*.f64 i y)))) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))
(/.f64 (fma.f64 (fma.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 i y) (*.f64 (*.f64 z z) z)) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (*.f64 (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 z (-.f64 z (*.f64 i y)))) (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))))) (*.f64 (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 z (-.f64 z (*.f64 i y)))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))))
(/.f64 (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64))) (fma.f64 i y (-.f64 z (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 i y (-.f64 z (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))) (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))) (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 3 binary64)))))
(/.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64)) (-.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (*.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z)))))
(/.f64 (fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y z) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 3 binary64))) (fma.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z)) (*.f64 (fma.f64 i y z) (fma.f64 i y z))))
(fma.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (fma.f64 i y z))
(fma.f64 (-.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 i y) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))) z)
(fma.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y (neg.f64 z))) (/.f64 #s(literal 1 binary64) (fma.f64 i y (neg.f64 z))) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
(fma.f64 (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t))) (fma.f64 i y (fma.f64 (log.f64 y) x z)))
(fma.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))) (fma.f64 i y z))
(fma.f64 (fma.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 i y) (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (*.f64 i y))))) z)
(fma.f64 (fma.f64 (*.f64 (*.f64 (*.f64 i y) i) y) (*.f64 i y) (*.f64 (*.f64 z z) z)) (/.f64 #s(literal 1 binary64) (fma.f64 (*.f64 (*.f64 i y) i) y (*.f64 z (-.f64 z (*.f64 i y))))) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
(fma.f64 (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 t (-.f64 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 i y (fma.f64 (log.f64 y) x z)))
(fma.f64 i y (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z))
(fma.f64 (log.f64 y) x (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y z)))
(fma.f64 y i (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z))
(fma.f64 x (log.f64 y) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y z)))
(-.f64 (/.f64 (*.f64 (fma.f64 i y z) (fma.f64 i y z)) (fma.f64 i y (-.f64 z (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))) (/.f64 (pow.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) #s(literal 2 binary64)) (fma.f64 i y (-.f64 z (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x z)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) t)
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x z)) t) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 (+.f64 (fma.f64 i y z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 (log.f64 y) x))) t)
(+.f64 (+.f64 (fma.f64 i y z) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (*.f64 (log.f64 y) x))
(+.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) (*.f64 i y))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 (log.f64 y) x)) (+.f64 t (fma.f64 i y z)))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
(+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (fma.f64 i y z))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y (fma.f64 (log.f64 y) x z)))
(+.f64 (fma.f64 i y z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) z)
(+.f64 (*.f64 (log.f64 y) x) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (fma.f64 i y z)))
(+.f64 (*.f64 i y) (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z))
(+.f64 z (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))
(*.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a)))
(*.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a) (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (/.f64 (*.f64 z z) (*.f64 a a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64))) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a)))) (neg.f64 (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a)))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (*.f64 (log.f64 y) x) (/.f64 a z) (*.f64 a #s(literal 1 binary64))) (*.f64 a (/.f64 a z)))
(/.f64 (fma.f64 (*.f64 (log.f64 y) x) (neg.f64 a) (*.f64 a (neg.f64 z))) (*.f64 a (neg.f64 a)))
(/.f64 (fma.f64 (*.f64 (log.f64 y) x) a (*.f64 a z)) (*.f64 a a))
(/.f64 (fma.f64 #s(literal 1 binary64) a (*.f64 (/.f64 a z) (*.f64 (log.f64 y) x))) (*.f64 (/.f64 a z) a))
(/.f64 (fma.f64 (neg.f64 z) a (*.f64 (neg.f64 a) (*.f64 (log.f64 y) x))) (*.f64 (neg.f64 a) a))
(/.f64 (fma.f64 z a (*.f64 a (*.f64 (log.f64 y) x))) (*.f64 a a))
(/.f64 (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a))) (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a) (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64)))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64))) (+.f64 (/.f64 (*.f64 z z) (*.f64 a a)) (-.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (*.f64 (*.f64 (log.f64 y) x) z) (*.f64 a a)))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 3 binary64))) (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a)) (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) a) (pow.f64 (/.f64 #s(literal 1 binary64) z) #s(literal -1 binary64)) (/.f64 (*.f64 (log.f64 y) x) a))
(fma.f64 (/.f64 #s(literal 1 binary64) a) z (/.f64 (*.f64 (log.f64 y) x) a))
(fma.f64 #s(literal 1 binary64) (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a))
(fma.f64 (neg.f64 z) (/.f64 #s(literal 1 binary64) (neg.f64 a)) (/.f64 (*.f64 (log.f64 y) x) a))
(fma.f64 (*.f64 (log.f64 y) x) (/.f64 #s(literal 1 binary64) a) (/.f64 z a))
(fma.f64 z (/.f64 #s(literal 1 binary64) a) (/.f64 (*.f64 (log.f64 y) x) a))
(fma.f64 (log.f64 y) (/.f64 x a) (/.f64 z a))
(fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a))
(fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))
(fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (/.f64 z a))
(-.f64 (/.f64 (pow.f64 (/.f64 (*.f64 (log.f64 y) x) a) #s(literal 2 binary64)) (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a)) (/.f64 (/.f64 (*.f64 z z) (*.f64 a a)) (/.f64 (fma.f64 (log.f64 y) x (neg.f64 z)) a)))
(+.f64 (/.f64 (*.f64 (log.f64 y) x) a) (/.f64 z a))
(+.f64 (/.f64 z a) (/.f64 (*.f64 (log.f64 y) x) a))
(*.f64 (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a)))
(*.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a) (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (/.f64 (*.f64 t t) (*.f64 a a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64))) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a)))) (neg.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a)))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (/.f64 a t) (*.f64 a #s(literal 1 binary64))) (*.f64 a (/.f64 a t)))
(/.f64 (fma.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (neg.f64 a) (*.f64 a (neg.f64 t))) (*.f64 a (neg.f64 a)))
(/.f64 (fma.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) a (*.f64 t a)) (*.f64 a a))
(/.f64 (fma.f64 #s(literal 1 binary64) a (*.f64 (/.f64 a t) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (*.f64 (/.f64 a t) a))
(/.f64 (fma.f64 (neg.f64 t) a (*.f64 (neg.f64 a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (*.f64 (neg.f64 a) a))
(/.f64 (fma.f64 t a (*.f64 a (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))) (*.f64 a a))
(/.f64 (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a) (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 3 binary64)))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 3 binary64))) (+.f64 (/.f64 (*.f64 t t) (*.f64 a a)) (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 (log.f64 c) t)) (*.f64 a a)))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 3 binary64))) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a))) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) a) (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)))
(fma.f64 (/.f64 #s(literal 1 binary64) a) t (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)))
(fma.f64 #s(literal 1 binary64) (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)))
(fma.f64 (neg.f64 t) (/.f64 #s(literal 1 binary64) (neg.f64 a)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)))
(fma.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (/.f64 #s(literal 1 binary64) a) (/.f64 t a))
(fma.f64 t (/.f64 #s(literal 1 binary64) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))
(fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(fma.f64 (log.f64 c) (*.f64 (/.f64 #s(literal 1 binary64) a) (-.f64 b #s(literal 1/2 binary64))) (/.f64 t a))
(-.f64 (/.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) #s(literal 2 binary64)) (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a)) (/.f64 (/.f64 (*.f64 t t) (*.f64 a a)) (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) a)))
(+.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)) (/.f64 t a))
(+.f64 (/.f64 t a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a)))
(*.f64 i y)
(*.f64 y i)
(*.f64 (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t))))
(*.f64 (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 t (-.f64 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)))))
(pow.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 t t))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 t (-.f64 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 (*.f64 t t) t (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 t t) (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 2 binary64))) (-.f64 t (*.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 t t))) (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t))))
(/.f64 (neg.f64 (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 t (-.f64 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)) (*.f64 t t)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t)) (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 t t))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 t (-.f64 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 (*.f64 t t) t (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 3 binary64)))))
(/.f64 (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (fma.f64 t t (-.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) t)))))
(/.f64 (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (fma.f64 t (-.f64 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 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) t)
(-.f64 (/.f64 (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) (neg.f64 t))) (/.f64 (*.f64 t t) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t))))
(+.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) t)
(+.f64 t (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(*.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))
(*.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 t t)) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 (log.f64 y) x)) t))
(/.f64 (-.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)))
(/.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)) (*.f64 (*.f64 t t) t)) (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (-.f64 (*.f64 t t) (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 (log.f64 y) x)) t))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.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)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64))) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))) (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (*.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 3 binary64)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 3 binary64))) (fma.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (-.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x)) (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64))))
(fma.f64 (-.f64 (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 2 binary64)) (*.f64 t t)) (/.f64 #s(literal 1 binary64) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (neg.f64 t))) (*.f64 (log.f64 y) x))
(fma.f64 (fma.f64 (*.f64 t t) t (pow.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 t (-.f64 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 (log.f64 y) x))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (+.f64 t (*.f64 (log.f64 y) x)))
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (+.f64 t (*.f64 (log.f64 y) x)))
(fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
(fma.f64 x (log.f64 y) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
(-.f64 (/.f64 (pow.f64 (*.f64 (log.f64 y) x) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (/.f64 (pow.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) #s(literal 2 binary64)) (-.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))))
(+.f64 (fma.f64 (log.f64 y) x t) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 (log.f64 y) x)) t)
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) (*.f64 (log.f64 y) x))
(+.f64 (*.f64 (log.f64 y) x) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))
(+.f64 (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c)) (+.f64 t (*.f64 (log.f64 y) x)))
(+.f64 t (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 (log.f64 y) x)))

eval344.0ms (2.5%)

Memory
-8.1MiB live, 556.5MiB allocated
Compiler

Compiled 58 367 to 2 548 computations (95.6% saved)

prune441.0ms (3.3%)

Memory
-5.1MiB live, 550.6MiB allocated
Pruning

39 alts after pruning (36 fresh and 3 done)

PrunedKeptTotal
New2 087162 103
Fresh42024
Picked325
Done011
Total2 094392 133
Accuracy
100.0%
Counts
2 133 → 39
Alt Table
Click to see full alt table
StatusAccuracyProgram
37.4%
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
▶80.6%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a)) (*.f64 y i))
79.7%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 #s(approx (+ (+ (* (/ x a) (log y)) (/ z a)) (+ (* (/ (log c) a) (- b 1/2)) (/ t a))) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a))) a a)) (*.f64 y i))
75.8%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x z))) b) (log.f64 c)) b)) (*.f64 y i))
60.2%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
32.8%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
35.6%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
33.5%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (*.f64 (/.f64 (log.f64 c) x) b)) x)) (*.f64 y i))
44.2%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.f64 y i))
63.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i #s(approx (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t)) (*.f64 (log.f64 y) x))) a) z) z z))
41.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
32.4%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 (log.f64 y) x)) a) a a))
40.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 i y)) a) a a))
66.1%
#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)) t))) a) z) (/.f64 #s(literal 1 binary64) z) z))
25.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
▶25.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z))
21.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
34.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
33.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (/.f64 (log.f64 c) z) b)) z z))
35.4%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 z a)) a a))
▶22.7%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
37.1%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 b (/.f64 (log.f64 c) a))) a a))
▶32.9%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
4.3%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))))))
13.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
25.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
25.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a)))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
76.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
72.3%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) z z))))
66.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))))
62.7%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
✓45.1%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
42.6%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
▶36.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
67.1%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 t i)) (fma.f64 (/.f64 x i) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) i) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z i)))) i))
✓14.9%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
✓24.4%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
22.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
51.8%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ t a) (+ (* (- b 1/2) (log c)) (+ (* y i) z))) (fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 y i) t)) (/.f64 z t)) (/.f64 a t)) t t)))
Compiler

Compiled 1 794 to 1 084 computations (39.6% saved)

simplify244.0ms (1.8%)

Memory
6.3MiB live, 273.5MiB allocated
Algorithm
1×egg-herbie
Localize:

Found 20 expressions of interest:

NewMetricScoreProgram
cost-diff0
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
cost-diff0
(*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
cost-diff0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z))
cost-diff1216
(fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)
cost-diff0
(*.f64 (log.f64 y) x)
cost-diff0
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
cost-diff0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
cost-diff192
(fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)
cost-diff0
#s(approx (+ t a) (fma.f64 (/.f64 a t) t t))
cost-diff0
(+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))
cost-diff0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
cost-diff896
(fma.f64 (/.f64 a t) t t)
cost-diff0
(/.f64 t a)
cost-diff0
#s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))
cost-diff0
(fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)
cost-diff0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
cost-diff320
(*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y))
cost-diff384
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))
cost-diff704
(fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)))
cost-diff1920
(fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a)
Rules
22 338×lower-fma.f32
22 324×lower-fma.f64
4 782×lower-*.f32
4 774×lower-*.f64
3 314×lower-+.f32
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
063689
095677
1177667
2396663
31324649
42083640
53838634
65239634
76480634
08009573
Stop Event
1×iter limit
1×node limit
1×iter limit
Calls
Call 1
Inputs
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a))
(fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a)
(fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)))
x
(*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y))
(/.f64 #s(literal 1 binary64) a)
#s(literal 1 binary64)
a
(log.f64 y)
y
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(/.f64 (log.f64 c) a)
(log.f64 c)
c
(/.f64 t a)
t
(/.f64 z a)
z
(*.f64 y i)
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
(fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)
#s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))
(/.f64 t a)
t
a
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
(+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))
#s(approx (+ t a) (fma.f64 (/.f64 a t) t t))
(fma.f64 (/.f64 a t) t t)
(/.f64 a t)
a
t
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))
(*.f64 y i)
y
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
(fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(log.f64 y)
y
x
#s(literal 1 binary64)
z
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z))
(fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)
(*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(log.f64 y)
y
x
z
(/.f64 #s(literal 1 binary64) z)
#s(literal 1 binary64)
Outputs
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a)) (*.f64 y i))
(fma.f64 i 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 (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a))
#s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x (+.f64 (+.f64 t z) a))))
(fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a)
(fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (log.f64 y) x (+.f64 (+.f64 t z) a)))
(fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (*.f64 (/.f64 #s(literal 1 binary64) a) (fma.f64 (log.f64 y) x (+.f64 t z))))
x
(*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y))
(/.f64 (log.f64 y) a)
(/.f64 #s(literal 1 binary64) a)
#s(literal 1 binary64)
a
(log.f64 y)
y
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 t z)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))
(fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (log.f64 c) (/.f64 t a))
(-.f64 b #s(literal 1/2 binary64))
b
#s(literal 1/2 binary64)
(/.f64 (log.f64 c) a)
(log.f64 c)
c
(/.f64 t a)
t
(/.f64 z a)
z
(*.f64 y i)
(*.f64 i y)
i
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
(fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)
#s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))
(/.f64 t a)
t
a
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 a t))))
(+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))
(+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 a t)))
#s(approx (+ t a) (fma.f64 (/.f64 a t) t t))
#s(approx (+ t a) (+.f64 a t))
(fma.f64 (/.f64 a t) t t)
(+.f64 a t)
(/.f64 a t)
a
t
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))
(*.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 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
(fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)
(+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(log.f64 y)
y
x
#s(literal 1 binary64)
z
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
(fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)
(+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
(*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(log.f64 y)
y
x
z
(/.f64 #s(literal 1 binary64) z)
#s(literal 1 binary64)

localize177.0ms (1.3%)

Memory
3.0MiB live, 313.7MiB allocated
Localize:

Found 20 expressions of interest:

NewMetricScoreProgram
accuracy0.25390625
(*.f64 (log.f64 y) x)
accuracy1.4850491164906865
(*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
accuracy21.711875924991915
(fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)
accuracy53.38495315841577
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
accuracy0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
accuracy0.00390625
(fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)
accuracy0.25390625
(*.f64 (log.f64 y) x)
accuracy53.38495315841577
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
accuracy0.00390625
(+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))
accuracy9.05916299124386
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
accuracy9.86983257209225
(fma.f64 (/.f64 a t) t t)
accuracy44.21229274609985
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))
accuracy0
(/.f64 t a)
accuracy0
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
accuracy12.920014404633413
(fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)
accuracy58.73662225661804
#s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))
accuracy0.3789041858302058
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))
accuracy0.8554666858302059
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))
accuracy1.2617077404222408
(fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)))
accuracy12.254247395439274
(fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a)
Samples
93.0ms255×0valid
1.0ms1×1valid
Compiler

Compiled 476 to 57 computations (88% saved)

Precisions
Click to see histograms. Total time spent on operations: 68.0ms
ival-add: 28.0ms (41.4% of total)
ival-mult: 19.0ms (28.1% of total)
ival-div: 11.0ms (16.3% of total)
ival-log: 7.0ms (10.4% of total)
ival-sub: 1.0ms (1.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)

series204.0ms (1.5%)

Memory
-6.4MiB live, 223.4MiB allocated
Counts
21 → 1 488
Calls
Call 1
Inputs
#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())
#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())
#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())
#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())
#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())
#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())
#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())
#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())
#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())
#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())
#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())
#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())
#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())
#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())
#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())
#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())
#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())
Outputs
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y)))) (taylor 0 x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y)))) (taylor 0 x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y)))) (taylor 0 x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x)))) (taylor inf x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x)))) (taylor inf x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x)))) (taylor inf x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1))) (taylor -inf a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1))) (taylor -inf a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1))) (taylor -inf a) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor -inf y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor -inf y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor -inf y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor -inf y) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) (taylor 0 b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c)))) (taylor 0 b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b)))) (taylor inf b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b)))) (taylor inf b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b)))) (taylor inf b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) (taylor inf c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) (taylor inf c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) (taylor inf c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) (taylor inf c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))) (taylor -inf c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))) (taylor -inf c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))) (taylor -inf c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))))) (taylor -inf c) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)))) (taylor inf t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)))) (taylor inf t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)))) (taylor inf t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor 0 z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)))) (taylor inf z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)))) (taylor inf z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)))) (taylor inf z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) (patch (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) a) (taylor inf x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))) (taylor inf x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))) (taylor inf x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x)))))) (taylor inf x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) a) (taylor -inf x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x))))) (taylor -inf x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x))))) (taylor -inf x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x))))) (taylor -inf x) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor inf a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor inf a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor inf a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor inf a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a)) (taylor -inf a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a)) (taylor -inf a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a)) (taylor -inf a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a)) (taylor -inf a) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (taylor inf y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (taylor inf y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (taylor inf y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (taylor inf y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) (taylor -inf y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) (taylor -inf y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) (taylor -inf y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) (taylor -inf y) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) (taylor 0 b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a))))) (taylor 0 b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a))))) (taylor 0 b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a))))) (taylor 0 b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor inf b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b))))))) (taylor inf b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b))))))) (taylor inf b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b))))))) (taylor inf b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor -inf b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b))))) (taylor -inf b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b))))) (taylor -inf b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b))))) (taylor -inf b) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) (taylor inf c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) (taylor inf c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) (taylor inf c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) (taylor inf c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))) (taylor -inf c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))) (taylor -inf c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))) (taylor -inf c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))) (taylor -inf c) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))) (taylor inf t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))) (taylor inf t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))) (taylor inf t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) (taylor 0 z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor inf z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))) (taylor inf z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))) (taylor inf z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))) (taylor inf z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor -inf z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) (patch (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* b (log c)) a)))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* b (log c)) a)))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* b (log c)) a)))) (taylor 0 b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor inf b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (log c) a))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (log c) a))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (log c) a))))) (taylor inf b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor -inf b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a))) b))))) (taylor -inf b) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a))) (taylor inf c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a))) (taylor inf c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a))) (taylor inf c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a))) (taylor inf c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))) (taylor -inf c) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (* (log c) (- b 1/2)))) a) (taylor 0 a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (* (log c) (- b 1/2)))) a) (taylor 0 a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (* (log c) (- b 1/2)))) a) (taylor 0 a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (* (log c) (- b 1/2)))) a) (taylor 0 a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (* (log c) (- b 1/2)))) a) (taylor inf a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (* (log c) (- b 1/2)))) a) (taylor inf a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (* (log c) (- b 1/2)))) a) (taylor inf a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (* (log c) (- b 1/2)))) a) (taylor inf a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a)) (taylor -inf a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a)) (taylor -inf a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a)) (taylor -inf a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a)) (taylor -inf a) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ z a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))) (taylor inf t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* (log c) (- b 1/2)) a)) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* (log c) (- b 1/2)) a)) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* (log c) (- b 1/2)) a)) t)) (/ 1 a)))) (taylor -inf t) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) (taylor 0 z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor inf z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))) (taylor inf z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))) (taylor inf z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))) (taylor inf z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor -inf z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) z)) (/ 1 a)))) (taylor -inf z) (#s(alt (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) (patch (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor 0 a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor 0 a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor 0 a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor 0 a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor inf a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor inf a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor inf a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor inf a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor -inf a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor -inf a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor -inf a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor -inf a) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor 0 y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor 0 y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor 0 y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (log y) a) (taylor 0 y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 y)) a)) (taylor inf y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 y)) a)) (taylor inf y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 y)) a)) (taylor inf y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 y)) a)) (taylor inf y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 y)))) a) (taylor -inf y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 y)))) a) (taylor -inf y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 y)))) a) (taylor -inf y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (/ (+ (log -1) (* -1 (log (/ -1 y)))) a) (taylor -inf y) (#s(alt (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (patch (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (patch (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) a) (taylor inf y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y))))))) (taylor inf y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y))))))) (taylor inf y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y))))))) (taylor inf y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) a) (taylor -inf y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y))))) (taylor -inf y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y))))) (taylor -inf y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y))))) (taylor -inf y) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) a) (taylor inf i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i))))))) (taylor inf i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i))))))) (taylor inf i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i))))))) (taylor inf i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* i y) a) (taylor -inf i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i))))) (taylor -inf i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i))))) (taylor -inf i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i))))) (taylor -inf i) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor inf z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))) (taylor inf z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ z a) (taylor -inf z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a)))) (taylor -inf z) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a) (taylor 0 x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) a) (taylor inf x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))) (taylor inf x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))) (taylor inf x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x))))))) (taylor inf x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* x (log y)) a) (taylor -inf x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x))))) (taylor -inf x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x))))) (taylor -inf x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x))))) (taylor -inf x) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) a) (taylor 0 b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a)))))) (taylor 0 b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a)))))) (taylor 0 b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a)))))) (taylor 0 b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor inf b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b)))))))) (taylor inf b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b)))))))) (taylor inf b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b)))))))) (taylor inf b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor -inf b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b))))) (taylor -inf b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b))))) (taylor -inf b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b))))) (taylor -inf b) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a) (taylor inf c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a) (taylor inf c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a) (taylor inf c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a) (taylor inf c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a) (taylor -inf c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a) (taylor -inf c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a) (taylor -inf c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a) (taylor -inf c) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a) (taylor 0 t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) (taylor 0 t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))) (taylor inf t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))) (taylor inf t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))) (taylor inf t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a)))) (taylor -inf t) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor 0 a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor inf a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor inf a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor inf a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor inf a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor -inf a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor -inf a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor -inf a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a) (taylor -inf a) (#s(alt #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (patch #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor 0 t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor 0 t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor 0 t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor 0 t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf t) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor 0 a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor 0 a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor 0 a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor 0 a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf a) (#s(alt (/.f64 t a) (patch (/.f64 t a) #<representation binary64>) () ())) ())
#s(alt t (taylor 0 a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt a (taylor 0 t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (/.f64 a t) t t) (patch (fma.f64 (/.f64 a t) t t) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))))) (taylor 0 b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b))))))) (taylor inf b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b))))) (taylor -inf b) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))))) (taylor inf c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* (log c) (- b 1/2))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (* (log c) (- b 1/2))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))))) (taylor inf z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1))) (taylor -inf z) (#s(alt (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) (patch (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))) #<representation binary64>) () ())) ())
#s(alt a (taylor 0 t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (/ a t))) (taylor inf t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ a t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt t (taylor 0 a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (+ a t) (taylor 0 a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (/ t a))) (taylor inf a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ t a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) (patch #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) (patch (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y)))))) (taylor inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))) (taylor inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))) (taylor inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) (taylor inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))) (taylor inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))) (taylor inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (patch #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (log (/ 1 y)))) (taylor inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log -1) (* -1 (log (/ -1 y))))) (taylor -inf y) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor 0 x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (*.f64 (log.f64 y) x) (patch (*.f64 (log.f64 y) x) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) (patch (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))) (taylor inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* x (log y)) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))) (taylor inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z))))))) (taylor inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt t (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))) (taylor inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt t (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1))) (taylor -inf t) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt a (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))) (taylor inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt a (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1))) (taylor -inf a) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))) (taylor inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))) (taylor inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) (patch #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* i (* y z)) (taylor inf y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* i z) (/ (* z (+ a (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) y))) (taylor inf y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* i z) (/ (* z (+ a (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) y))) (taylor inf y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* y (+ (* i z) (/ (* z (+ a (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) y))) (taylor inf y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* i (* y z)) (taylor -inf y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (* i z)) (* -1 (/ (* z (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (* i z)) (* -1 (/ (* z (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 (* i z)) (* -1 (/ (* z (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y))))) (taylor -inf y) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* i (* y z)) (taylor inf i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ (* y z) (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))) (taylor inf i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ (* y z) (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))) (taylor inf i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* i (+ (* y z) (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))) (taylor inf i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* i (* y z)) (taylor -inf i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (* y z)) (* -1 (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (* y z)) (* -1 (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 (* y z)) (* -1 (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i))))) (taylor -inf i) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) (taylor 0 x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* x (* z (log y))) (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* x (* z (log y))) (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* x (* z (log y))) (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))))) (taylor 0 x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* x (* z (log y))) (taylor inf x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* z (log y)) (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x))) (taylor inf x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* z (log y)) (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x))) (taylor inf x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* x (+ (* z (log y)) (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x))) (taylor inf x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* x (* z (log y))) (taylor -inf x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (* z (log y))) (* -1 (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (* z (log y))) (* -1 (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* x (+ (* -1 (* z (log y))) (* -1 (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x))))) (taylor -inf x) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) (taylor 0 b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* b (* z (log c))) (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* b (* z (log c))) (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* b (* z (log c))) (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))) (taylor 0 b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* b (* z (log c))) (taylor inf b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* z (log c)) (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))) (taylor inf b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* z (log c)) (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))) (taylor inf b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* z (log c)) (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))) (taylor inf b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* b (* z (log c))) (taylor -inf b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (* z (log c))) (* -1 (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (* z (log c))) (* -1 (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (* z (log c))) (* -1 (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b))))) (taylor -inf b) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))) (taylor inf c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))) (taylor -inf c) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* t z) (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* t z) (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* t z) (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* t z) (taylor inf t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ z (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t))) (taylor inf t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ z (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t))) (taylor inf t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* t (+ z (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t))) (taylor inf t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* t z) (taylor -inf t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 z) (* -1 (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t))))) (taylor -inf t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 z) (* -1 (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t))))) (taylor -inf t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (+ (* -1 z) (* -1 (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t))))) (taylor -inf t) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) (taylor 0 a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* a z) (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* a z) (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* a z) (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* a z) (taylor inf a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ z (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a))) (taylor inf a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ z (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a))) (taylor inf a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* a (+ z (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a))) (taylor inf a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* a z) (taylor -inf a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (+ (* -1 z) (* -1 (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a))))) (taylor -inf a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (+ (* -1 z) (* -1 (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a))))) (taylor -inf a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* -1 (* a (+ (* -1 z) (* -1 (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a))))) (taylor -inf a) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor 0 z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor inf z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor inf z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor inf z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor inf z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor -inf z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor -inf z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor -inf z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))) (taylor -inf z) (#s(alt (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (patch (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (/ t a)) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a))) (taylor 0 b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a)))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a)))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a)))) (taylor inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* b (log c)) a) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b))))) (taylor -inf b) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a)) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a)) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a)) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a)) (taylor inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)) (taylor -inf c) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor 0 a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor 0 a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor 0 a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor 0 a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor inf a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor inf a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor inf a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (+ t (* (log c) (- b 1/2))) a) (taylor inf a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a)) (taylor -inf a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a)) (taylor -inf a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a)) (taylor -inf a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a)) (taylor -inf a) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ (* (log c) (- b 1/2)) a) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) (taylor 0 t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t)))) (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t)))) (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t)))) (taylor inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (/ t a) (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a)))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a)))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a)))) (taylor -inf t) (#s(alt (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (patch (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (* i y))) (taylor 0 b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))) (taylor 0 b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))) (taylor 0 b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y)))) (taylor 0 b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b))))) (taylor inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b))))) (taylor inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b))))) (taylor inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* b (log c)) (taylor -inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b))))) (taylor -inf b) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y))) (taylor inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))) (taylor -inf c) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (* (log c) (- b 1/2))) (taylor 0 y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))) (taylor inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))) (taylor inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))) (taylor inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y))))) (taylor -inf y) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (* (log c) (- b 1/2))) (taylor 0 i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))) (taylor inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))) (taylor inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i)))) (taylor inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* i y) (taylor -inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i))))) (taylor -inf i) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ (* i y) (* (log c) (- b 1/2))) (taylor 0 z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (+ z (+ (* i y) (* (log c) (- b 1/2)))) (taylor 0 z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) (taylor inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) (taylor inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z)))) (taylor inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt z (taylor -inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
#s(alt (* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1))) (taylor -inf z) (#s(alt #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) (patch #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)) #<representation binary64>) () ())) ())
Calls

372 calls:

TimeVariablePointExpression
2.0ms
t
@inf
(+ (* x (* (/ 1 a) (log y))) (+ (+ (* (- b 1/2) (/ (log c) a)) (/ t a)) (/ z a)))
2.0ms
b
@0
(* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z)
0.0ms
y
@-inf
(* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z)
0.0ms
y
@-inf
(* (/ 1 a) (log y))
0.0ms
c
@-inf
(* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z)

simplify366.0ms (2.7%)

Memory
-7.3MiB live, 317.9MiB allocated
Algorithm
1×egg-herbie
Rules
8 690×lower-+.f64
8 690×lower-+.f32
8 512×lower-fma.f64
8 512×lower-fma.f32
4 876×lower-*.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
078730133
1270329623
0836726772
Stop Event
1×iter limit
1×node limit
Counts
1 488 → 1 416
Calls
Call 1
Inputs
(+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(* b (log c))
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
t
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
t
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
z
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
z
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(/ (* x (log y)) a)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(/ (* x (log y)) a)
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(/ (* b (log c)) a)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(/ (* b (log c)) a)
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(/ t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(/ t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(/ z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(/ z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* b (log c)) a))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* b (log c)) a))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* b (log c)) a))))
(/ (* b (log c)) a)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (log c) a)))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (log c) a)))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (log c) a)))))
(/ (* b (log c)) a)
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a))) b)))))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a)))
(+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a))
(+ (/ z a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(/ t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))
(/ t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* (log c) (- b 1/2)) a)) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* (log c) (- b 1/2)) a)) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* (log c) (- b 1/2)) a)) t)) (/ 1 a))))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(/ z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))
(/ z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) z)) (/ 1 a))))
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(/ (log y) a)
(* -1 (/ (log (/ 1 y)) a))
(* -1 (/ (log (/ 1 y)) a))
(* -1 (/ (log (/ 1 y)) a))
(* -1 (/ (log (/ 1 y)) a))
(/ (+ (log -1) (* -1 (log (/ -1 y)))) a)
(/ (+ (log -1) (* -1 (log (/ -1 y)))) a)
(/ (+ (log -1) (* -1 (log (/ -1 y)))) a)
(/ (+ (log -1) (* -1 (log (/ -1 y)))) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(/ (* i y) a)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(/ (* i y) a)
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(/ (* i y) a)
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(/ (* i y) a)
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(/ z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(/ z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(/ (* x (log y)) a)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(/ (* x (log y)) a)
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) a)
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(/ (* b (log c)) a)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(/ (* b (log c)) a)
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(/ t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(/ t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
(/ t a)
t
(+ a t)
(+ a t)
(+ a t)
a
(* a (+ 1 (/ t a)))
(* a (+ 1 (/ t a)))
(* a (+ 1 (/ t a)))
a
(* -1 (* a (- (* -1 (/ t a)) 1)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
a
(+ a t)
(+ a t)
(+ a t)
t
(* t (+ 1 (/ a t)))
(* t (+ 1 (/ a t)))
(* t (+ 1 (/ a t)))
t
(* -1 (* t (- (* -1 (/ a t)) 1)))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(* i y)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
a
(+ a t)
(+ a t)
(+ a t)
t
(* t (+ 1 (/ a t)))
(* t (+ 1 (/ a t)))
(* t (+ 1 (/ a t)))
t
(* -1 (* t (- (* -1 (/ a t)) 1)))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(* -1 (* t (- (* -1 (/ a t)) 1)))
t
(+ a t)
(+ a t)
(+ a t)
a
(* a (+ 1 (/ t a)))
(* a (+ 1 (/ t a)))
(* a (+ 1 (/ t a)))
a
(* -1 (* a (- (* -1 (/ t a)) 1)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* -1 (* x (log (/ 1 y))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(* x (log y))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* x (log y))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(* x (log y))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i (* y z))
(* y (+ (* i z) (/ (* z (+ a (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) y)))
(* y (+ (* i z) (/ (* z (+ a (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) y)))
(* y (+ (* i z) (/ (* z (+ a (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) y)))
(* i (* y z))
(* -1 (* y (+ (* -1 (* i z)) (* -1 (/ (* z (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 (* i z)) (* -1 (/ (* z (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* -1 (* y (+ (* -1 (* i z)) (* -1 (/ (* z (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* i (* y z))
(* i (+ (* y z) (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))
(* i (+ (* y z) (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))
(* i (+ (* y z) (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))
(* i (* y z))
(* -1 (* i (+ (* -1 (* y z)) (* -1 (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 (* y z)) (* -1 (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* -1 (* i (+ (* -1 (* y z)) (* -1 (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))))
(+ (* x (* z (log y))) (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))))
(+ (* x (* z (log y))) (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))))
(+ (* x (* z (log y))) (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))))
(* x (* z (log y)))
(* x (+ (* z (log y)) (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))
(* x (+ (* z (log y)) (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))
(* x (+ (* z (log y)) (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))
(* x (* z (log y)))
(* -1 (* x (+ (* -1 (* z (log y))) (* -1 (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (* z (log y))) (* -1 (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* -1 (* x (+ (* -1 (* z (log y))) (* -1 (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+ (* b (* z (log c))) (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))))
(+ (* b (* z (log c))) (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))))
(+ (* b (* z (log c))) (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))))
(* b (* z (log c)))
(* b (+ (* z (log c)) (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))
(* b (+ (* z (log c)) (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))
(* b (+ (* z (log c)) (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))
(* b (* z (log c)))
(* -1 (* b (+ (* -1 (* z (log c))) (* -1 (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (* z (log c))) (* -1 (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* -1 (* b (+ (* -1 (* z (log c))) (* -1 (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ (* t z) (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ (* t z) (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ (* t z) (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* t z)
(* t (+ z (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))
(* t (+ z (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))
(* t (+ z (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))
(* t z)
(* -1 (* t (+ (* -1 z) (* -1 (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))))
(* -1 (* t (+ (* -1 z) (* -1 (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))))
(* -1 (* t (+ (* -1 z) (* -1 (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))))
(* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+ (* a z) (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ (* a z) (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ (* a z) (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* a z)
(* a (+ z (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))
(* a (+ z (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))
(* a (+ z (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))
(* a z)
(* -1 (* a (+ (* -1 z) (* -1 (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))))
(* -1 (* a (+ (* -1 z) (* -1 (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))))
(* -1 (* a (+ (* -1 z) (* -1 (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+ (* -1/2 (/ (log c) a)) (/ t a))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(/ (* b (log c)) a)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(/ (* b (log c)) a)
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(/ (* (log c) (- b 1/2)) a)
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(/ t a)
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(/ t a)
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(+ z (+ (* -1/2 (log c)) (* i y)))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(* b (log c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(* b (log c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(+ z (* (log c) (- b 1/2)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(* i y)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(* i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(+ z (* (log c) (- b 1/2)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(* i y)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(* i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(+ (* i y) (* (log c) (- b 1/2)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
z
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
z
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
Outputs
(+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))))
(fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a a)
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a (fma.f64 (log.f64 y) x a))
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a (fma.f64 (log.f64 y) x a))
(+ a (+ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) (* x (log y))))
(fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a (fma.f64 (log.f64 y) x a))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(*.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) x) (+.f64 (/.f64 a x) (log.f64 y))) x)
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(*.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) x) (+.f64 (/.f64 a x) (log.f64 y))) x)
(* x (+ (log y) (+ (/ a x) (/ (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))) x))))
(*.f64 (fma.f64 a (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) x) (+.f64 (/.f64 a x) (log.f64 y))) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) a a) (neg.f64 x)) (log.f64 y)))
(+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
a
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))) #s(literal 1 binary64)))
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))) #s(literal 1 binary64)))
(* -1 (* a (- (+ (* -1 (/ t a)) (+ (* -1 (/ z a)) (+ (* -1 (/ (* x (log y)) a)) (* -1 (/ (* (log c) (- b 1/2)) a))))) 1)))
(*.f64 (neg.f64 a) (-.f64 (neg.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))) #s(literal 1 binary64)))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) a a)
(+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a (fma.f64 b (log.f64 c) a))
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a (fma.f64 b (log.f64 c) a))
(+ a (+ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) (* b (log c))))
(fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a (fma.f64 b (log.f64 c) a))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(*.f64 (fma.f64 a (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) b) (+.f64 (/.f64 a b) (log.f64 c))) b)
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(*.f64 (fma.f64 a (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) b) (+.f64 (/.f64 a b) (log.f64 c))) b)
(* b (+ (log c) (+ (/ a b) (/ (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))) b))))
(*.f64 (fma.f64 a (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) b) (+.f64 (/.f64 a b) (log.f64 c))) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (* a (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) a a) (neg.f64 b)) (log.f64 c)))
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))) (/.f64 t a)) a a)
(+ a (* a (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))) (/.f64 t a)) a a)
(+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) a a)
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) a (+.f64 t a))
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) a (+.f64 t a))
(+ a (+ t (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) a (+.f64 t a))
t
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
(fma.f64 (fma.f64 a (/.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) t) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
(fma.f64 (fma.f64 a (/.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) t) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (/ (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t))))
(fma.f64 (fma.f64 a (/.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) t) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) a a) (neg.f64 t)) #s(literal 1 binary64)))
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) a a) (neg.f64 t)) #s(literal 1 binary64)))
(* -1 (* t (- (* -1 (/ (+ a (* a (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) t)) 1)))
(*.f64 (neg.f64 t) (-.f64 (/.f64 (fma.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) a a) (neg.f64 t)) #s(literal 1 binary64)))
(+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(fma.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) a a)
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) a (+.f64 z a))
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) a (+.f64 z a))
(+ a (+ z (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) a (+.f64 z a))
z
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
(fma.f64 (fma.f64 a (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) z) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
(fma.f64 (fma.f64 a (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) z) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (/ (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z))))
(fma.f64 (fma.f64 a (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) z) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(*.f64 (neg.f64 z) (-.f64 (/.f64 (fma.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) a a) (neg.f64 z)) #s(literal 1 binary64)))
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(*.f64 (neg.f64 z) (-.f64 (/.f64 (fma.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) a a) (neg.f64 z)) #s(literal 1 binary64)))
(* -1 (* z (- (* -1 (/ (+ a (* a (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))) z)) 1)))
(*.f64 (neg.f64 z) (-.f64 (/.f64 (fma.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) a a) (neg.f64 z)) #s(literal 1 binary64)))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(/ (* x (log y)) a)
(/.f64 (*.f64 (log.f64 y) x) a)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(*.f64 (+.f64 (+.f64 (/.f64 z (*.f64 x a)) (/.f64 (log.f64 y) a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (/.f64 t (*.f64 x a)))) x)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(*.f64 (+.f64 (+.f64 (/.f64 z (*.f64 x a)) (/.f64 (log.f64 y) a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (/.f64 t (*.f64 x a)))) x)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (/ (* (log c) (- b 1/2)) (* a x))))))
(*.f64 (+.f64 (+.f64 (/.f64 z (*.f64 x a)) (/.f64 (log.f64 y) a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (/.f64 t (*.f64 x a)))) x)
(/ (* x (log y)) a)
(/.f64 (*.f64 (log.f64 y) x) a)
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) a)
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) a)
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(/.f64 (-.f64 (fma.f64 (neg.f64 x) (log.f64 y) (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(/.f64 (-.f64 (fma.f64 (neg.f64 x) (log.f64 y) (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(/.f64 (-.f64 (fma.f64 (neg.f64 x) (log.f64 y) (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (+ (* -1 (* x (log y))) (* -1 (* (log c) (- b 1/2)))))) a))
(/.f64 (-.f64 (fma.f64 (neg.f64 x) (log.f64 y) (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* x (log (/ 1 y))) a)) (+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a))))
(+.f64 (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 b (/.f64 (log.f64 c) a) (/.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 b (/.f64 (log.f64 c) a) (/.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (/ (* x (log y)) a)))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 b (/.f64 (log.f64 c) a) (/.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))))
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 t (*.f64 b a)) (/.f64 z (*.f64 b a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 b a)) (/.f64 (log.f64 c) a)))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 t (*.f64 b a)) (/.f64 z (*.f64 b a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 b a)) (/.f64 (log.f64 c) a)))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (/ (* x (log y)) (* a b)))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 t (*.f64 b a)) (/.f64 z (*.f64 b a))) (fma.f64 x (/.f64 (log.f64 y) (*.f64 b a)) (/.f64 (log.f64 c) a)))) b)
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a)))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (+ (/ z a) (/ (* x (log y)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))))
(+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))) (/.f64 t a))
(+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))
(fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(/ t a)
(/.f64 t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 z (*.f64 t a)))) (/.f64 #s(literal 1 binary64) a)) t)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 z (*.f64 t a)))) (/.f64 #s(literal 1 binary64) a)) t)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t))))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 z (*.f64 t a)))) (/.f64 #s(literal 1 binary64) a)) t)
(/ t a)
(/.f64 t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))
(fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a)))
(/ z a)
(/.f64 z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 t (*.f64 z a)))) (/.f64 #s(literal 1 binary64) a)) z)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 t (*.f64 z a)))) (/.f64 #s(literal 1 binary64) a)) z)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z))))))
(*.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 t (*.f64 z a)))) (/.f64 #s(literal 1 binary64) a)) z)
(/ z a)
(/.f64 z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a))) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a)))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 z a) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* b (log c)) a))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (fma.f64 b (/.f64 (log.f64 c) a) (+.f64 (/.f64 z a) (/.f64 t a))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* b (log c)) a))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (fma.f64 b (/.f64 (log.f64 c) a) (+.f64 (/.f64 z a) (/.f64 t a))))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (/ (* b (log c)) a))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (fma.f64 b (/.f64 (log.f64 c) a) (+.f64 (/.f64 z a) (/.f64 t a))))
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (log c) a)))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z (*.f64 b a)) (/.f64 (log.f64 c) a)) (/.f64 t (*.f64 b a)))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (log c) a)))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z (*.f64 b a)) (/.f64 (log.f64 c) a)) (/.f64 t (*.f64 b a)))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (/ (log c) a)))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 z (*.f64 b a)) (/.f64 (log.f64 c) a)) (/.f64 t (*.f64 b a)))) b)
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 z a) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 z a) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ z a))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (/.f64 z a) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (+ (/ t a) (/ z a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (/.f64 z a) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (/.f64 z a) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (/.f64 z a) (/.f64 t a)))
(+ (/ t a) (+ (/ z a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a)))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (+.f64 (/.f64 z a) (/.f64 t a)))
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(/ (+ t (+ z (* (log c) (- b 1/2)))) a)
(/.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a))
(/.f64 (-.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a))
(/.f64 (-.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a))
(/.f64 (-.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (+ (* -1 z) (* -1 (* (log c) (- b 1/2))))) a))
(/.f64 (-.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) (neg.f64 a))
(+ (/ z a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(/ t a)
(/.f64 t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (+.f64 (/.f64 z (*.f64 t a)) (/.f64 #s(literal 1 binary64) a))) t)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (+.f64 (/.f64 z (*.f64 t a)) (/.f64 #s(literal 1 binary64) a))) t)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (+.f64 (/.f64 z (*.f64 t a)) (/.f64 #s(literal 1 binary64) a))) t)
(/ t a)
(/.f64 t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* (log c) (- b 1/2)) a)) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* (log c) (- b 1/2)) a)) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (/ (* (log c) (- b 1/2)) a)) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (/ (* (log c) (- b 1/2)) a)))
(+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))
(/ z a)
(/.f64 z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 z a)) (+.f64 (/.f64 t (*.f64 z a)) (/.f64 #s(literal 1 binary64) a))) z)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 z a)) (+.f64 (/.f64 t (*.f64 z a)) (/.f64 #s(literal 1 binary64) a))) z)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 z a)) (+.f64 (/.f64 t (*.f64 z a)) (/.f64 #s(literal 1 binary64) a))) z)
(/ z a)
(/.f64 z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (/ (* (log c) (- b 1/2)) a)) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a)) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(/ (log y) a)
(/.f64 (log.f64 y) a)
(* -1 (/ (log (/ 1 y)) a))
(/.f64 (log.f64 y) a)
(* -1 (/ (log (/ 1 y)) a))
(/.f64 (log.f64 y) a)
(* -1 (/ (log (/ 1 y)) a))
(/.f64 (log.f64 y) a)
(* -1 (/ (log (/ 1 y)) a))
(/.f64 (log.f64 y) a)
(/ (+ (log -1) (* -1 (log (/ -1 y)))) a)
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a)
(/ (+ (log -1) (* -1 (log (/ -1 y)))) a)
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a)
(/ (+ (log -1) (* -1 (log (/ -1 y)))) a)
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a)
(/ (+ (log -1) (* -1 (log (/ -1 y)))) a)
(/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(/ (* i y) a)
(/.f64 (*.f64 i y) a)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) (*.f64 y a)) (+.f64 (+.f64 (/.f64 i a) (/.f64 t (*.f64 y a))) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y a)) (/.f64 z (*.f64 y a))))) y)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) (*.f64 y a)) (+.f64 (+.f64 (/.f64 i a) (/.f64 t (*.f64 y a))) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y a)) (/.f64 z (*.f64 y a))))) y)
(* y (+ (* -1 (/ (* x (log (/ 1 y))) (* a y))) (+ (/ i a) (+ (/ t (* a y)) (+ (/ z (* a y)) (/ (* (log c) (- b 1/2)) (* a y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) (*.f64 y a)) (+.f64 (+.f64 (/.f64 i a) (/.f64 t (*.f64 y a))) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 y a)) (/.f64 z (*.f64 y a))))) y)
(/ (* i y) a)
(/.f64 (*.f64 i y) a)
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) (neg.f64 y)) (/.f64 i a)) (neg.f64 y))
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) (neg.f64 y)) (/.f64 i a)) (neg.f64 y))
(* -1 (* y (+ (* -1 (/ i a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (+ (log -1) (* -1 (log (/ -1 y))))) a) (/ (* (log c) (- b 1/2)) a)))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 x (/.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) (neg.f64 y)) (/.f64 i a)) (neg.f64 y))
(/ (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) z) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(/ (* i y) a)
(/.f64 (*.f64 i y) a)
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 i a)) (/.f64 y a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 i a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 i a)) (/.f64 z (*.f64 i a))))) i)
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 i a)) (/.f64 y a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 i a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 i a)) (/.f64 z (*.f64 i a))))) i)
(* i (+ (/ t (* a i)) (+ (/ y a) (+ (/ z (* a i)) (+ (/ (* x (log y)) (* a i)) (/ (* (log c) (- b 1/2)) (* a i)))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 i a)) (/.f64 y a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 i a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 i a)) (/.f64 z (*.f64 i a))))) i)
(/ (* i y) a)
(/.f64 (*.f64 i y) a)
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(*.f64 (-.f64 (/.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) (neg.f64 i)) (/.f64 y a)) (neg.f64 i))
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(*.f64 (-.f64 (/.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) (neg.f64 i)) (/.f64 y a)) (neg.f64 i))
(* -1 (* i (+ (* -1 (/ y a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) i)))))
(*.f64 (-.f64 (/.f64 (fma.f64 x (/.f64 (log.f64 y) a) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)) (/.f64 t a))) (neg.f64 i)) (/.f64 y a)) (neg.f64 i))
(/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(/ z a)
(/.f64 z a)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(*.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 z a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 t (*.f64 z a))))) (/.f64 #s(literal 1 binary64) a)) z)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(*.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 z a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 t (*.f64 z a))))) (/.f64 #s(literal 1 binary64) a)) z)
(* z (+ (/ 1 a) (+ (/ t (* a z)) (+ (/ (* i y) (* a z)) (+ (/ (* x (log y)) (* a z)) (/ (* (log c) (- b 1/2)) (* a z)))))))
(*.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 z a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 z a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 z a)) (/.f64 t (*.f64 z a))))) (/.f64 #s(literal 1 binary64) a)) z)
(/ z a)
(/.f64 z a)
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a)))) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a)))) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(* -1 (* z (- (* -1 (/ (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) z)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a)))) (neg.f64 z)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 z))
(/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(/ (* x (log y)) a)
(/.f64 (*.f64 (log.f64 y) x) a)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 x a)) (/.f64 z (*.f64 x a))) (fma.f64 i (/.f64 y (*.f64 x a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (/.f64 (log.f64 y) a)))) x)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 x a)) (/.f64 z (*.f64 x a))) (fma.f64 i (/.f64 y (*.f64 x a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (/.f64 (log.f64 y) a)))) x)
(* x (+ (/ t (* a x)) (+ (/ z (* a x)) (+ (/ (log y) a) (+ (/ (* i y) (* a x)) (/ (* (log c) (- b 1/2)) (* a x)))))))
(*.f64 (+.f64 (+.f64 (/.f64 t (*.f64 x a)) (/.f64 z (*.f64 x a))) (fma.f64 i (/.f64 y (*.f64 x a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 x a)) (/.f64 (log.f64 y) a)))) x)
(/ (* x (log y)) a)
(/.f64 (*.f64 (log.f64 y) x) a)
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(* -1 (* x (+ (* -1 (/ (log y) a)) (* -1 (/ (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a)))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) (neg.f64 x)) (/.f64 (log.f64 y) a)))
(/ (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) a)
(/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 b (/.f64 (log.f64 c) a) (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)))) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 b (/.f64 (log.f64 c) a) (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)))) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* b (log c)) a) (+ (/ (* i y) a) (/ (* x (log y)) a))))))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 b (/.f64 (log.f64 c) a) (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a)))) (/.f64 t a)))
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 t (*.f64 b a)) (/.f64 z (*.f64 b a))) (fma.f64 i (/.f64 y (*.f64 b a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 b a)) (/.f64 (log.f64 c) a))))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 t (*.f64 b a)) (/.f64 z (*.f64 b a))) (fma.f64 i (/.f64 y (*.f64 b a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 b a)) (/.f64 (log.f64 c) a))))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (+ (/ z (* a b)) (+ (/ (log c) a) (+ (/ (* i y) (* a b)) (/ (* x (log y)) (* a b))))))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (+.f64 (/.f64 t (*.f64 b a)) (/.f64 z (*.f64 b a))) (fma.f64 i (/.f64 y (*.f64 b a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 b a)) (/.f64 (log.f64 c) a))))) b)
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* x (log y)) a))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 z a))) (/.f64 t a))) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t 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)) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t 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)) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t 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)) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))) a)
(/.f64 (+.f64 (+.f64 t 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)) (fma.f64 i y (*.f64 (log.f64 y) x)))) a)
(/ (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)
(/.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a)
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))
(+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a))
(/ t a)
(/.f64 t a)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(*.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 t a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 z (*.f64 t a))))) (/.f64 #s(literal 1 binary64) a)) t)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(*.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 t a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 z (*.f64 t a))))) (/.f64 #s(literal 1 binary64) a)) t)
(* t (+ (/ 1 a) (+ (/ z (* a t)) (+ (/ (* i y) (* a t)) (+ (/ (* x (log y)) (* a t)) (/ (* (log c) (- b 1/2)) (* a t)))))))
(*.f64 (+.f64 (fma.f64 i (/.f64 y (*.f64 t a)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (fma.f64 x (/.f64 (log.f64 y) (*.f64 t a)) (/.f64 z (*.f64 t a))))) (/.f64 #s(literal 1 binary64) a)) t)
(/ t a)
(/.f64 t a)
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))) t)) (/ 1 a))))
(*.f64 (-.f64 (/.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (neg.f64 t)) (/.f64 #s(literal 1 binary64) a)) (neg.f64 t))
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)
(/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
(/ t a)
(/.f64 t a)
t
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
a
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
a
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
a
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
t
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
t
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (-.f64 (/.f64 a (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (-.f64 (/.f64 a (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (-.f64 (/.f64 a (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (fma.f64 i (/.f64 y t) (/.f64 z t))) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (fma.f64 i (/.f64 y t) (/.f64 z t))) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (fma.f64 i (/.f64 y t) (/.f64 z t))) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) a) (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) a) (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (* (log c) (- b 1/2))))) t)) 1)))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) a) (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
(+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a))) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) (neg.f64 a)) #s(literal 1 binary64)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) (neg.f64 a)) #s(literal 1 binary64)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))) a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) (neg.f64 a)) #s(literal 1 binary64)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y)))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (/ (* i y) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (/.f64 z b)) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z)) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z)) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (* i y))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z)) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (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 i y z)) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (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 i y z)) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (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 i y z)) (+.f64 t a))
(+ a (+ t (+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (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 i y z)) (+.f64 t a))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(* i y)
(*.f64 i y)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y))) y)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y))) y)
(* y (+ i (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) y) i)) (neg.f64 y))
(+ a (+ t (+ z (* (log c) (- b 1/2)))))
(+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (/.f64 z i)) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (/.f64 z i)) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (* (log c) (- b 1/2))))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) t) a) i) y)) (neg.f64 i))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (fma.f64 i (/.f64 y z) (/.f64 t z))) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (fma.f64 i (/.f64 y z) (/.f64 t z))) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))))
(fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (fma.f64 i (/.f64 y z) (/.f64 t z))) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 z)) z (neg.f64 z)))
a
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
t
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
(* t (+ 1 (/ a t)))
(fma.f64 (/.f64 a t) t t)
t
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (-.f64 (/.f64 a (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (-.f64 (/.f64 a (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
(* -1 (* t (- (* -1 (/ a t)) 1)))
(*.f64 (-.f64 (/.f64 a (neg.f64 t)) #s(literal 1 binary64)) (neg.f64 t))
t
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
(+ a t)
(+.f64 t a)
a
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
(* a (+ 1 (/ t a)))
(fma.f64 (/.f64 t a) a a)
a
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
(* -1 (* a (- (* -1 (/ t a)) 1)))
(*.f64 (neg.f64 a) (-.f64 (/.f64 (neg.f64 t) a) #s(literal 1 binary64)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 t y)) (/.f64 a y))) i) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 t y)) (/.f64 a y))) i) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (/ (* (log c) (- b 1/2)) y))))))
(*.f64 (+.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 t y)) (/.f64 a y))) i) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 y)) i) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 y)) i) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2))))) y)))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 y)) i) (neg.f64 y))
(+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 t i)))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 t i)))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 t i)))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 t x))) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 t x))) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x))))))
(*.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 t x))) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))
(+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a)
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 t b))) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 t b))) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ (* i y) b) (/ (* x (log y)) b)))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 t b))) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (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 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (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 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (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 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))))
(+.f64 (+.f64 t a) (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 i y (*.f64 (log.f64 y) x))))
(+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(+.f64 (fma.f64 i y (*.f64 (log.f64 y) x)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
t
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (*.f64 (log.f64 y) x)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (*.f64 (log.f64 y) x)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (*.f64 (log.f64 y) x)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))
(fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
a
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a)))) a a)
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a)))) a a)
(* a (+ 1 (+ (/ t a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a))))))
(fma.f64 (fma.f64 i (/.f64 y a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 x (/.f64 (log.f64 y) a) (/.f64 t a)))) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) (neg.f64 a)) a (neg.f64 a)))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (log (/ 1 y))))
(*.f64 (neg.f64 x) (neg.f64 (log.f64 y)))
(* -1 (* x (log (/ 1 y))))
(*.f64 (neg.f64 x) (neg.f64 (log.f64 y)))
(* -1 (* x (log (/ 1 y))))
(*.f64 (neg.f64 x) (neg.f64 (log.f64 y)))
(* -1 (* x (log (/ 1 y))))
(*.f64 (neg.f64 x) (neg.f64 (log.f64 y)))
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (+ (log -1) (* -1 (log (/ -1 y)))))
(*.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* x (log y))
(*.f64 (log.f64 y) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (+ (log y) (+ (/ a x) (+ (/ t x) (+ (/ z x) (+ (/ (* i y) x) (/ (* (log c) (- b 1/2)) x)))))))
(*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (fma.f64 i (/.f64 y x) (/.f64 z x))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)
(* x (log y))
(*.f64 (log.f64 y) x)
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(* -1 (* x (+ (* -1 (log y)) (* -1 (/ (+ a (+ t (+ z (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (-.f64 (/.f64 (+.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) t) a) (neg.f64 x)) (log.f64 y)))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* y (+ i (+ (* -1 (/ (* x (log (/ 1 y))) y)) (+ (/ a y) (+ (/ t y) (+ (/ z y) (/ (* (log c) (- b 1/2)) y)))))))
(*.f64 (fma.f64 (neg.f64 x) (/.f64 (neg.f64 (log.f64 y)) y) (+.f64 (+.f64 i (/.f64 a y)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (/.f64 z y)) (/.f64 t y)))) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ a (+ t (+ z (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 y) (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 y)) i))
(+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
z
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
(* z (+ 1 (+ (/ a z) (+ (/ t z) (+ (/ (* i y) z) (+ (/ (* x (log y)) z) (/ (* (log c) (- b 1/2)) z)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y z) (fma.f64 x (/.f64 (log.f64 y) z) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z)))) (/.f64 t z)) (/.f64 a z)) z z)
z
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) (neg.f64 z)) z (neg.f64 z)))
(+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
t
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
(* t (+ 1 (+ (/ a t) (+ (/ z t) (+ (/ (* i y) t) (+ (/ (* x (log y)) t) (/ (* (log c) (- b 1/2)) t)))))))
(fma.f64 (+.f64 (+.f64 (fma.f64 i (/.f64 y t) (fma.f64 x (/.f64 (log.f64 y) t) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t)))) (/.f64 z t)) (/.f64 a t)) t t)
t
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(* -1 (* t (- (* -1 (/ (+ a (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) (neg.f64 t)) t (neg.f64 t)))
(+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t)
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
a
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
(* a (+ 1 (+ (/ t a) (+ (/ z a) (+ (/ (* i y) a) (+ (/ (* x (log y)) a) (/ (* (log c) (- b 1/2)) a)))))))
(fma.f64 (+.f64 (fma.f64 i (/.f64 y a) (fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 z a)))) (/.f64 t a)) a a)
a
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(* -1 (* a (- (* -1 (/ (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)) 1)))
(neg.f64 (fma.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) t) (neg.f64 a)) a (neg.f64 a)))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a)
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (+ (* i y) (* x (log y))))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ a b) (+ (/ t b) (+ (/ z b) (+ (/ (* i y) b) (/ (* x (log y)) b))))))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (+.f64 (+.f64 (fma.f64 i (/.f64 y b) (fma.f64 x (/.f64 (log.f64 y) b) (/.f64 z b))) (/.f64 t b)) (/.f64 a b))) (log.f64 c)) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ a (+ t (+ z (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (+.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) z) t) a) (neg.f64 b)) (log.f64 c)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(+.f64 (+.f64 (+.f64 t a) 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)) (fma.f64 i y (*.f64 (log.f64 y) x))))
(+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2))))))
(+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+ a (+ t (+ z (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(+.f64 (+.f64 t a) (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i (+ y (+ (/ a i) (+ (/ t i) (+ (/ z i) (+ (/ (* x (log y)) i) (/ (* (log c) (- b 1/2)) i)))))))
(*.f64 (+.f64 (+.f64 y (/.f64 a i)) (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 z i))) (/.f64 t i))) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ a (+ t (+ z (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (-.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) (neg.f64 i)) y) (neg.f64 i))
(* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))
(*.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) z)
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* i (* y z))
(*.f64 (*.f64 y z) i)
(* y (+ (* i z) (/ (* z (+ a (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) y)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (-.f64 t (*.f64 (neg.f64 x) (log.f64 y))) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) y) i)) y)
(* y (+ (* i z) (/ (* z (+ a (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) y)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (-.f64 t (*.f64 (neg.f64 x) (log.f64 y))) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) y) i)) y)
(* y (+ (* i z) (/ (* z (+ a (+ t (+ (* -1 (* x (log (/ 1 y)))) (* (log c) (- b 1/2)))))) y)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (-.f64 t (*.f64 (neg.f64 x) (log.f64 y))) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) y) i)) y)
(* i (* y z))
(*.f64 (*.f64 y z) i)
(* -1 (* y (+ (* -1 (* i z)) (* -1 (/ (* z (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 (*.f64 z (+.f64 i (/.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) y)))) (neg.f64 y))
(* -1 (* y (+ (* -1 (* i z)) (* -1 (/ (* z (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 (*.f64 z (+.f64 i (/.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) y)))) (neg.f64 y))
(* -1 (* y (+ (* -1 (* i z)) (* -1 (/ (* z (+ a (+ t (+ (* x (+ (log -1) (* -1 (log (/ -1 y))))) (* (log c) (- b 1/2)))))) y)))))
(*.f64 (neg.f64 (*.f64 z (+.f64 i (/.f64 (+.f64 (fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) y))) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) y)))) (neg.f64 y))
(* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2))))))
(*.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) z)
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(+ (* i (* y z)) (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* i (* y z))
(*.f64 (*.f64 y z) i)
(* i (+ (* y z) (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) i) y)) i)
(* i (+ (* y z) (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) i) y)) i)
(* i (+ (* y z) (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) i) y)) i)
(* i (* y z))
(*.f64 (*.f64 y z) i)
(* -1 (* i (+ (* -1 (* y z)) (* -1 (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (neg.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) i) y))) (neg.f64 i))
(* -1 (* i (+ (* -1 (* y z)) (* -1 (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (neg.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) i) y))) (neg.f64 i))
(* -1 (* i (+ (* -1 (* y z)) (* -1 (/ (* z (+ a (+ t (+ (* x (log y)) (* (log c) (- b 1/2)))))) i)))))
(*.f64 (neg.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) i) y))) (neg.f64 i))
(* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) z)
(+ (* x (* z (log y))) (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))))
(fma.f64 (*.f64 x z) (log.f64 y) (*.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) z))
(+ (* x (* z (log y))) (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))))
(fma.f64 (*.f64 x z) (log.f64 y) (*.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) z))
(+ (* x (* z (log y))) (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))))
(fma.f64 (*.f64 x z) (log.f64 y) (*.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) z))
(* x (* z (log y)))
(*.f64 (*.f64 (log.f64 y) z) x)
(* x (+ (* z (log y)) (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) x) (log.f64 y))) x)
(* x (+ (* z (log y)) (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) x) (log.f64 y))) x)
(* x (+ (* z (log y)) (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) x) (log.f64 y))) x)
(* x (* z (log y)))
(*.f64 (*.f64 (log.f64 y) z) x)
(* -1 (* x (+ (* -1 (* z (log y))) (* -1 (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (neg.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) x) (log.f64 y)))))
(* -1 (* x (+ (* -1 (* z (log y))) (* -1 (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (neg.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) x) (log.f64 y)))))
(* -1 (* x (+ (* -1 (* z (log y))) (* -1 (/ (* z (+ a (+ t (+ (* i y) (* (log c) (- b 1/2)))))) x)))))
(*.f64 (neg.f64 x) (neg.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) a) x) (log.f64 y)))))
(* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y)))))))
(*.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) z)
(+ (* b (* z (log c))) (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))))
(fma.f64 (*.f64 (log.f64 c) z) b (*.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) z))
(+ (* b (* z (log c))) (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))))
(fma.f64 (*.f64 (log.f64 c) z) b (*.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) z))
(+ (* b (* z (log c))) (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))))
(fma.f64 (*.f64 (log.f64 c) z) b (*.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) z))
(* b (* z (log c)))
(*.f64 (*.f64 (log.f64 c) z) b)
(* b (+ (* z (log c)) (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) b) (log.f64 c))) b)
(* b (+ (* z (log c)) (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) b) (log.f64 c))) b)
(* b (+ (* z (log c)) (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))
(*.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) b) (log.f64 c))) b)
(* b (* z (log c)))
(*.f64 (*.f64 (log.f64 c) z) b)
(* -1 (* b (+ (* -1 (* z (log c))) (* -1 (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (neg.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) b) (log.f64 c)))))
(* -1 (* b (+ (* -1 (* z (log c))) (* -1 (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (neg.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) b) (log.f64 c)))))
(* -1 (* b (+ (* -1 (* z (log c))) (* -1 (/ (* z (+ a (+ t (+ (* -1/2 (log c)) (+ (* i y) (* x (log y))))))) b)))))
(*.f64 (neg.f64 b) (neg.f64 (*.f64 z (+.f64 (/.f64 (+.f64 (+.f64 (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 i y (*.f64 (log.f64 y) x))) t) a) b) (log.f64 c)))))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (+ (* i y) (* x (log y)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(*.f64 (+.f64 (+.f64 t a) (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 i y (*.f64 (log.f64 y) x)))) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(*.f64 (+.f64 (+.f64 t a) (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 i y (*.f64 (log.f64 y) x)))) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(*.f64 (+.f64 (+.f64 t a) (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 i y (*.f64 (log.f64 y) x)))) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)))))))
(*.f64 (+.f64 (+.f64 t a) (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 i y (*.f64 (log.f64 y) x)))) z)
(* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(*.f64 (+.f64 (fma.f64 i y (*.f64 (log.f64 y) x)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) z)
(+ (* t z) (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(+ (* t z) (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(+ (* t z) (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* t z)
(*.f64 z t)
(* t (+ z (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))
(*.f64 (fma.f64 z (/.f64 (+.f64 (fma.f64 i y (*.f64 (log.f64 y) x)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) t) z) t)
(* t (+ z (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))
(*.f64 (fma.f64 z (/.f64 (+.f64 (fma.f64 i y (*.f64 (log.f64 y) x)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) t) z) t)
(* t (+ z (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))
(*.f64 (fma.f64 z (/.f64 (+.f64 (fma.f64 i y (*.f64 (log.f64 y) x)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) t) z) t)
(* t z)
(*.f64 z t)
(* -1 (* t (+ (* -1 z) (* -1 (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))))
(*.f64 (neg.f64 (fma.f64 z (/.f64 (+.f64 (fma.f64 i y (*.f64 (log.f64 y) x)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) t) z)) (neg.f64 t))
(* -1 (* t (+ (* -1 z) (* -1 (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))))
(*.f64 (neg.f64 (fma.f64 z (/.f64 (+.f64 (fma.f64 i y (*.f64 (log.f64 y) x)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) t) z)) (neg.f64 t))
(* -1 (* t (+ (* -1 z) (* -1 (/ (* z (+ a (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) t)))))
(*.f64 (neg.f64 (fma.f64 z (/.f64 (+.f64 (fma.f64 i y (*.f64 (log.f64 y) x)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) a)) t) z)) (neg.f64 t))
(* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2))))))
(*.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) z)
(+ (* a z) (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(+ (* a z) (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(+ (* a z) (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* a z)
(*.f64 z a)
(* a (+ z (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))
(*.f64 (fma.f64 z (/.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) a)
(* a (+ z (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))
(*.f64 (fma.f64 z (/.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) a)
(* a (+ z (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))
(*.f64 (fma.f64 z (/.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z) a)
(* a z)
(*.f64 z a)
(* -1 (* a (+ (* -1 z) (* -1 (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))))
(*.f64 (neg.f64 a) (neg.f64 (fma.f64 z (/.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)))
(* -1 (* a (+ (* -1 z) (* -1 (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))))
(*.f64 (neg.f64 a) (neg.f64 (fma.f64 z (/.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)))
(* -1 (* a (+ (* -1 z) (* -1 (/ (* z (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))) a)))))
(*.f64 (neg.f64 a) (neg.f64 (fma.f64 z (/.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)))
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(* z (+ a (+ t (+ (* i y) (+ (* x (log y)) (* (log c) (- b 1/2)))))))
(*.f64 (+.f64 (fma.f64 i y (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) z)
(+ (* -1/2 (/ (log c) a)) (/ t a))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (/.f64 t a))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (fma.f64 b (/.f64 (log.f64 c) a) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (fma.f64 b (/.f64 (log.f64 c) a) (/.f64 t a)))
(+ (* -1/2 (/ (log c) a)) (+ (/ t a) (/ (* b (log c)) a)))
(fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (fma.f64 b (/.f64 (log.f64 c) a) (/.f64 t a)))
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (/.f64 t (*.f64 b a)) (/.f64 (log.f64 c) a))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (/.f64 t (*.f64 b a)) (/.f64 (log.f64 c) a))) b)
(* b (+ (* -1/2 (/ (log c) (* a b))) (+ (/ t (* a b)) (/ (log c) a))))
(*.f64 (fma.f64 (/.f64 (log.f64 c) (*.f64 b a)) #s(literal -1/2 binary64) (+.f64 (/.f64 t (*.f64 b a)) (/.f64 (log.f64 c) a))) b)
(/ (* b (log c)) a)
(*.f64 b (/.f64 (log.f64 c) a))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (/.f64 t a)) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (/.f64 t a)) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(* -1 (* b (+ (* -1 (/ (log c) a)) (* -1 (/ (+ (* -1/2 (/ (log c) a)) (/ t a)) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 (/.f64 (log.f64 c) a) #s(literal -1/2 binary64) (/.f64 t a)) (neg.f64 b)) (/.f64 (log.f64 c) a)))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (* -1 (/ (* (log (/ 1 c)) (- b 1/2)) a)) (/ t a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2)) a))
(fma.f64 (-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) c))) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(/ (+ t (* (log c) (- b 1/2))) a)
(/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t) a)
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(/.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(/.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(/.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (neg.f64 a))
(* -1 (/ (+ (* -1 t) (* -1 (* (log c) (- b 1/2)))) a))
(/.f64 (neg.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t)) (neg.f64 a))
(/ (* (log c) (- b 1/2)) a)
(*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(+ (/ t a) (/ (* (log c) (- b 1/2)) a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(/ t a)
(/.f64 t a)
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a)) t)
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a)) t)
(* t (+ (/ 1 a) (/ (* (log c) (- b 1/2)) (* a t))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a)) t)
(/ t a)
(/.f64 t a)
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(*.f64 (neg.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(*.f64 (neg.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a))) (neg.f64 t))
(* -1 (* t (- (* -1 (/ (* (log c) (- b 1/2)) (* a t))) (/ 1 a))))
(*.f64 (neg.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) (*.f64 t a)) (/.f64 #s(literal 1 binary64) a))) (neg.f64 t))
(+ z (+ (* -1/2 (log c)) (* i y)))
(fma.f64 i y (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* -1/2 (log c)) (+ (* b (log c)) (* i y))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(* b (log c))
(*.f64 b (log.f64 c))
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (/.f64 z b)) (fma.f64 i (/.f64 y b) (log.f64 c))) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (/.f64 z b)) (fma.f64 i (/.f64 y b) (log.f64 c))) b)
(* b (+ (log c) (+ (* -1/2 (/ (log c) b)) (+ (/ z b) (/ (* i y) b)))))
(*.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) b) #s(literal -1/2 binary64) (/.f64 z b)) (fma.f64 i (/.f64 y b) (log.f64 c))) b)
(* b (log c))
(*.f64 b (log.f64 c))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 i y (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z)) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 i y (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z)) (neg.f64 b)) (log.f64 c)))
(* -1 (* b (+ (* -1 (log c)) (* -1 (/ (+ z (+ (* -1/2 (log c)) (* i y))) b)))))
(*.f64 (neg.f64 b) (-.f64 (/.f64 (fma.f64 i y (fma.f64 #s(literal -1/2 binary64) (log.f64 c) z)) (neg.f64 b)) (log.f64 c)))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* -1 (* (log (/ 1 c)) (- b 1/2))) (* i y)))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(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 i y z))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(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 i y z))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(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 i y z))
(+ z (+ (* i y) (* (+ (log -1) (* -1 (log (/ -1 c)))) (- b 1/2))))
(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 i y z))
(+ z (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(* i y)
(*.f64 i y)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (+.f64 (/.f64 z y) i)) y)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (+.f64 (/.f64 z y) i)) y)
(* y (+ i (+ (/ z y) (/ (* (log c) (- b 1/2)) y))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) y) (+.f64 (/.f64 z y) i)) y)
(* i y)
(*.f64 i y)
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) y) i)) (neg.f64 y))
(* -1 (* y (+ (* -1 i) (* -1 (/ (+ z (* (log c) (- b 1/2))) y)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) y) i)) (neg.f64 y))
(+ z (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(* i y)
(*.f64 i y)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (+.f64 (/.f64 z i) y)) i)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (+.f64 (/.f64 z i) y)) i)
(* i (+ y (+ (/ z i) (/ (* (log c) (- b 1/2)) i))))
(*.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (+.f64 (/.f64 z i) y)) i)
(* i y)
(*.f64 i y)
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) i) y)) (neg.f64 i))
(* -1 (* i (+ (* -1 y) (* -1 (/ (+ z (* (log c) (- b 1/2))) i)))))
(*.f64 (neg.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) i) y)) (neg.f64 i))
(+ (* i y) (* (log c) (- b 1/2)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
(+ z (+ (* i y) (* (log c) (- b 1/2))))
(fma.f64 i y (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))
z
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(*.f64 (fma.f64 i (/.f64 y z) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 1 binary64))) z)
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(*.f64 (fma.f64 i (/.f64 y z) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 1 binary64))) z)
(* z (+ 1 (+ (/ (* i y) z) (/ (* (log c) (- b 1/2)) z))))
(*.f64 (fma.f64 i (/.f64 y z) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) #s(literal 1 binary64))) z)
z
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)) (neg.f64 z)) z (neg.f64 z)))
(* -1 (* z (- (* -1 (/ (+ (* i y) (* (log c) (- b 1/2))) z)) 1)))
(neg.f64 (fma.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)) (neg.f64 z)) z (neg.f64 z)))

rewrite253.0ms (1.9%)

Memory
26.6MiB live, 328.7MiB allocated
Rules
5 342×lower-fma.f32
5 328×lower-fma.f64
4 254×lower-*.f32
4 246×lower-*.f64
3 532×lower-pow.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
061509
090497
1464491
24548479
08835434
Stop Event
1×iter limit
1×node limit
1×iter limit
Counts
21 → 337
Calls
Call 1
Inputs
(fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a)
(fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a)))
(+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))
(*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
(fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)
#s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))
(/.f64 t a)
(fma.f64 (/.f64 a t) t t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
(+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))
#s(approx (+ t a) (fma.f64 (/.f64 a t) t t))
(fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
(*.f64 (log.f64 y) x)
(fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z))
(*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))
Outputs
(*.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) #s(literal 1 binary64)) a)
(*.f64 (-.f64 (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64)) (*.f64 a a)) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a (neg.f64 a))))
(*.f64 (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 a (-.f64 a (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a)) (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64)))))
(*.f64 a (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) #s(literal 1 binary64)))
(pow.f64 (/.f64 (fma.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a (neg.f64 a)) (-.f64 (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64)) (*.f64 a a))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 a (-.f64 a (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a)) (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64))) (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 a a) (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64))) (-.f64 a (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a)))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64)) (*.f64 a a))) (neg.f64 (fma.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a (neg.f64 a))))
(/.f64 (neg.f64 (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 3 binary64)))) (neg.f64 (fma.f64 a (-.f64 a (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a)) (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64)) (*.f64 a a)) (fma.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a (neg.f64 a)))
(/.f64 (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 3 binary64))) (fma.f64 a a (-.f64 (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64)) (*.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) a))))
(/.f64 (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 3 binary64))) (fma.f64 a (-.f64 a (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a)) (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a (neg.f64 a)) (-.f64 (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64)) (*.f64 a a))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 a (-.f64 a (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a)) (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64))) (fma.f64 (*.f64 a a) a (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 3 binary64)))))
(fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a))
(fma.f64 (/.f64 a t) t (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a))
(fma.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a a)
(fma.f64 t (/.f64 a t) (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a))
(fma.f64 a (/.f64 t t) (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a))
(fma.f64 a (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a)
(fma.f64 a #s(literal 1 binary64) (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a))
(-.f64 (/.f64 (pow.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) #s(literal 2 binary64)) (fma.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a (neg.f64 a))) (/.f64 (*.f64 a a) (fma.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a (neg.f64 a))))
(+.f64 (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a) a)
(+.f64 a (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) a))
(*.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (-.f64 (*.f64 (/.f64 (log.f64 y) a) x) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))))
(*.f64 (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 3 binary64)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (*.f64 (/.f64 (log.f64 y) a) x)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) a) x) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 2 binary64)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (*.f64 (/.f64 (log.f64 y) a) x)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64))) (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 3 binary64)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (/.f64 z a)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 2 binary64)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64))) (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (*.f64 (/.f64 (log.f64 y) a) x)))
(/.f64 (+.f64 (pow.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #s(literal 3 binary64)) (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a))) (+.f64 (pow.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) #s(literal 2 binary64)) (-.f64 (/.f64 (*.f64 z z) (*.f64 a a)) (*.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (/.f64 z a)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 2 binary64)))) (neg.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) a) x) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))))
(/.f64 (neg.f64 (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 3 binary64)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (*.f64 (/.f64 (log.f64 y) a) x)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 2 binary64))) (-.f64 (*.f64 (/.f64 (log.f64 y) a) x) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 3 binary64)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 3 binary64))) (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 2 binary64)) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 (log.f64 y) a) x) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))))))
(/.f64 (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 3 binary64)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 3 binary64))) (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (*.f64 (/.f64 (log.f64 y) a) x)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (*.f64 (/.f64 (log.f64 y) a) x) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 2 binary64)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (*.f64 (/.f64 (log.f64 y) a) x)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64))) (+.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 3 binary64)) (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 3 binary64)))))
(fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))
(fma.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a)) (+.f64 (/.f64 z a) (*.f64 (/.f64 (log.f64 y) a) x)))
(fma.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (/.f64 z a))) (*.f64 (/.f64 (log.f64 y) a) x))
(fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))) (+.f64 (/.f64 z a) (*.f64 (/.f64 (log.f64 y) a) x)))
(fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64)))) (*.f64 (/.f64 (log.f64 y) a) x))
(fma.f64 (neg.f64 z) (/.f64 #s(literal 1 binary64) (neg.f64 a)) (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))))
(fma.f64 (*.f64 (log.f64 y) x) (/.f64 #s(literal 1 binary64) a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))
(fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) a) (fma.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t) (*.f64 (/.f64 (log.f64 y) a) x)))
(fma.f64 z (/.f64 #s(literal 1 binary64) a) (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))))
(fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (fma.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t) (*.f64 (/.f64 (log.f64 y) a) x)))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (fma.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t) (*.f64 (/.f64 (log.f64 y) a) x)))
(fma.f64 (log.f64 c) (*.f64 (/.f64 #s(literal 1 binary64) a) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t) (*.f64 (/.f64 (log.f64 y) a) x)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (fma.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t) (*.f64 (/.f64 (log.f64 y) a) x)))
(fma.f64 (/.f64 (log.f64 y) a) x (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))
(fma.f64 (log.f64 y) (/.f64 x a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))
(fma.f64 (/.f64 #s(literal 1 binary64) a) (*.f64 (log.f64 y) x) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))
(fma.f64 (/.f64 #s(literal 1 binary64) a) z (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))))
(fma.f64 #s(literal 1 binary64) (/.f64 z a) (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))))
(fma.f64 x (/.f64 (log.f64 y) a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))
(-.f64 (/.f64 (pow.f64 (*.f64 (/.f64 (log.f64 y) a) x) #s(literal 2 binary64)) (-.f64 (*.f64 (/.f64 (log.f64 y) a) x) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))) (/.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) #s(literal 2 binary64)) (-.f64 (*.f64 (/.f64 (log.f64 y) a) x) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))))
(+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))
(+.f64 (fma.f64 (/.f64 (log.f64 y) a) x (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)))
(+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (/.f64 z a))
(+.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) (fma.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t) (*.f64 (/.f64 (log.f64 y) a) x)))
(+.f64 (*.f64 (/.f64 (log.f64 y) a) x) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))
(+.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (*.f64 (/.f64 (log.f64 y) a) x))
(+.f64 (/.f64 z a) (fma.f64 (/.f64 x a) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))))
(+.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (+.f64 (/.f64 z a) (*.f64 (/.f64 (log.f64 y) a) x)))
(*.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (/.f64 z a))))
(*.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (/.f64 z a)) (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))) (-.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))
(/.f64 (-.f64 (/.f64 (*.f64 z z) (*.f64 a a)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64))) (-.f64 (/.f64 z a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))))
(/.f64 (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) (*.f64 (*.f64 a a) a)) (*.f64 (*.f64 (+.f64 z t) (+.f64 z t)) (+.f64 z t)))) (+.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (-.f64 (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))) (*.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t))))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a)))) (neg.f64 (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (/.f64 z a))))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (neg.f64 z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a) (*.f64 (neg.f64 a) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))))) (*.f64 (neg.f64 a) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a)))
(/.f64 (fma.f64 (neg.f64 z) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (*.f64 (neg.f64 a) (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))))) (*.f64 (neg.f64 a) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))))
(/.f64 (fma.f64 z (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a) (*.f64 a (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))))) (*.f64 a (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a)))
(/.f64 (fma.f64 z (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (*.f64 a (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))))) (*.f64 a (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))))
(/.f64 (fma.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a) (*.f64 (/.f64 a z) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))))) (*.f64 (/.f64 a z) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a)))
(/.f64 (fma.f64 #s(literal 1 binary64) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (*.f64 (/.f64 a z) (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))))) (*.f64 (/.f64 a z) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (neg.f64 a) (*.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a) (neg.f64 z))) (*.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a) (neg.f64 a)))
(/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) a (*.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a) z)) (*.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a) a))
(/.f64 (fma.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (/.f64 a z) (*.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a) #s(literal 1 binary64))) (*.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a) (/.f64 a z)))
(/.f64 (fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (neg.f64 a) (*.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (neg.f64 z))) (*.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (neg.f64 a)))
(/.f64 (fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) a (*.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) z)) (*.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) a))
(/.f64 (fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 a z) (*.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) #s(literal 1 binary64))) (*.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (/.f64 a z)))
(/.f64 (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a))) (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (/.f64 z a)))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 3 binary64))) (+.f64 (/.f64 (*.f64 z z) (*.f64 a a)) (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64)) (*.f64 (/.f64 z a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 3 binary64))) (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (/.f64 z a)) (-.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64)) (/.f64 (*.f64 z z) (*.f64 a a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 z a) (-.f64 (/.f64 z a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 z z) z) (*.f64 (*.f64 a a) a)) (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 3 binary64)))))
(fma.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 t)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (neg.f64 a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))
(fma.f64 (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))
(fma.f64 (/.f64 #s(literal 1 binary64) (neg.f64 a)) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 t)) #s(literal -1 binary64)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))
(fma.f64 (/.f64 #s(literal 1 binary64) (neg.f64 a)) (neg.f64 t) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))
(fma.f64 (*.f64 t #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))
(fma.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a)) (/.f64 z a))
(fma.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))) (/.f64 z a))
(fma.f64 (neg.f64 t) (/.f64 #s(literal 1 binary64) (neg.f64 a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))
(fma.f64 (neg.f64 z) (/.f64 #s(literal 1 binary64) (neg.f64 a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)))
(fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) a) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))
(fma.f64 z (/.f64 #s(literal 1 binary64) a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)))
(fma.f64 t (/.f64 #s(literal 1 binary64) a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))
(fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))
(fma.f64 (log.f64 c) (*.f64 (/.f64 #s(literal 1 binary64) a) (-.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))
(fma.f64 (/.f64 #s(literal 1 binary64) a) (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))
(fma.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) a) z (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)))
(fma.f64 (/.f64 #s(literal 1 binary64) a) t (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))
(fma.f64 #s(literal 1 binary64) (/.f64 z a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)))
(fma.f64 #s(literal 1 binary64) (/.f64 t a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))
(-.f64 (/.f64 (pow.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) #s(literal 2 binary64)) (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (/.f64 z a))) (/.f64 (/.f64 (*.f64 z z) (*.f64 a a)) (-.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (/.f64 z a))))
(+.f64 (+.f64 (/.f64 z a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (/.f64 t a))
(+.f64 (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(+.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) (*.f64 (/.f64 #s(literal 1 binary64) a) (+.f64 z t)))
(+.f64 (/.f64 z a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)))
(+.f64 (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a)) (/.f64 z a))
(+.f64 (/.f64 t a) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z a)))
(*.f64 (log.f64 y) (/.f64 #s(literal 1 binary64) a))
(*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 y) a))
(pow.f64 (/.f64 a (log.f64 y)) #s(literal -1 binary64))
(/.f64 (*.f64 #s(literal -1 binary64) (log.f64 y)) (neg.f64 a))
(/.f64 (*.f64 (log.f64 y) #s(literal -1 binary64)) (neg.f64 a))
(/.f64 (neg.f64 (log.f64 y)) (neg.f64 a))
(/.f64 (log.f64 y) a)
(/.f64 #s(literal 1 binary64) (/.f64 a (log.f64 y)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
(*.f64 (+.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #s(literal 1 binary64)) a)
(*.f64 (*.f64 (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a))))
(*.f64 (fma.f64 (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))) (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a) (*.f64 (*.f64 a a) a)) (/.f64 #s(literal 1 binary64) (fma.f64 a (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a)) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))))))
(*.f64 a (+.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) #s(literal 1 binary64)))
(pow.f64 (/.f64 (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a)) (*.f64 (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 a (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a)) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (fma.f64 (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))) (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a) (*.f64 (*.f64 a a) a))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 a a) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a)))
(/.f64 (neg.f64 (*.f64 (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a)))) (neg.f64 (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a))))
(/.f64 (neg.f64 (fma.f64 (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))) (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a) (*.f64 (*.f64 a a) a))) (neg.f64 (fma.f64 a (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a)) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))))))
(/.f64 (*.f64 (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a))) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a)))
(/.f64 (fma.f64 (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))) (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a) (*.f64 (*.f64 a a) a)) (fma.f64 a a (-.f64 (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))) (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)))))
(/.f64 (fma.f64 (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))) (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a) (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a)) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a)) (*.f64 (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 a (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a)) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (fma.f64 (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))) (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a) (*.f64 (*.f64 a a) a))))
(fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))
(fma.f64 (/.f64 a t) t (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))
(fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a)
(fma.f64 t (/.f64 a t) (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))
(fma.f64 a (/.f64 t t) (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))
(fma.f64 a #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a)
(fma.f64 a #s(literal 1 binary64) (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))
(-.f64 (/.f64 (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a))) (/.f64 (*.f64 a a) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a (neg.f64 a))))
(+.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a) a)
(+.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))
#s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 t)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (neg.f64 a)))
(*.f64 (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) a))
(*.f64 (/.f64 #s(literal 1 binary64) (neg.f64 a)) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 t)) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) (neg.f64 a)) (neg.f64 t))
(*.f64 (*.f64 t #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) a))
(*.f64 (neg.f64 t) (/.f64 #s(literal 1 binary64) (neg.f64 a)))
(*.f64 t (/.f64 #s(literal 1 binary64) a))
(*.f64 (/.f64 #s(literal 1 binary64) a) (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)))
(*.f64 (/.f64 #s(literal 1 binary64) a) t)
(*.f64 #s(literal 1 binary64) (/.f64 t a))
(pow.f64 (/.f64 (/.f64 a t) #s(literal 1 binary64)) #s(literal -1 binary64))
(pow.f64 (/.f64 a t) #s(literal -1 binary64))
(pow.f64 (/.f64 t a) #s(literal 1 binary64))
(/.f64 (*.f64 t #s(literal -1 binary64)) (neg.f64 a))
(/.f64 (neg.f64 (neg.f64 t)) (neg.f64 (neg.f64 a)))
(/.f64 (*.f64 t #s(literal 1 binary64)) a)
(/.f64 (neg.f64 t) (neg.f64 a))
(/.f64 #s(literal -1 binary64) (neg.f64 (/.f64 a t)))
(/.f64 t a)
(/.f64 (/.f64 #s(literal 1 binary64) a) (/.f64 #s(literal 1 binary64) t))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 a t) #s(literal 1 binary64)))
(/.f64 #s(literal 1 binary64) (/.f64 a t))
(neg.f64 (/.f64 (neg.f64 t) a))
(neg.f64 (/.f64 t (neg.f64 a)))
(exp.f64 (*.f64 (log.f64 (/.f64 a t)) #s(literal -1 binary64)))
(*.f64 (+.f64 (/.f64 a t) #s(literal 1 binary64)) t)
(*.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)))
(*.f64 (*.f64 (+.f64 t a) (-.f64 a t)) (/.f64 #s(literal 1 binary64) (-.f64 a t)))
(*.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (/.f64 #s(literal 1 binary64) (fma.f64 a (-.f64 a t) (*.f64 t t))))
(*.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (/.f64 #s(literal 1 binary64) (fma.f64 t (-.f64 t a) (*.f64 a a))))
(*.f64 t (+.f64 (/.f64 a t) #s(literal 1 binary64)))
(pow.f64 (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 a (-.f64 a t) (*.f64 t t)) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a))) #s(literal -1 binary64))
(pow.f64 (/.f64 (-.f64 a t) (*.f64 (+.f64 t a) (-.f64 a t))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 t (-.f64 t a) (*.f64 a a)) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a))) #s(literal -1 binary64))
(/.f64 (neg.f64 (*.f64 (+.f64 t a) (-.f64 t a))) (neg.f64 (-.f64 t a)))
(/.f64 (neg.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a))) (neg.f64 (fma.f64 a (-.f64 a t) (*.f64 t t))))
(/.f64 (neg.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a))) (neg.f64 (fma.f64 t (-.f64 t a) (*.f64 a a))))
(/.f64 (neg.f64 (*.f64 (+.f64 t a) (-.f64 a t))) (neg.f64 (-.f64 a t)))
(/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a))
(/.f64 (*.f64 (+.f64 t a) (-.f64 a t)) (-.f64 a t))
(/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t)))
(/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 t (-.f64 t a) (*.f64 a a)))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 a (-.f64 a t) (*.f64 t t)) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 a t) (*.f64 (+.f64 t a) (-.f64 a t))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 t (-.f64 t a) (*.f64 a a)) (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a))))
(fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) t)
(fma.f64 (/.f64 a t) t t)
(fma.f64 t (/.f64 a t) t)
(fma.f64 a (/.f64 t t) t)
(fma.f64 a #s(literal 1 binary64) t)
(-.f64 (/.f64 (*.f64 t t) (-.f64 t a)) (/.f64 (*.f64 a a) (-.f64 t a)))
(-.f64 (/.f64 (*.f64 a a) (-.f64 a t)) (/.f64 (*.f64 t t) (-.f64 a t)))
(+.f64 t a)
(+.f64 a t)
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))))
(*.f64 (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))) (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))) (/.f64 #s(literal 1 binary64) (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))))
(*.f64 (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a))) #s(approx (+ t a) (+.f64 t a)))) (/.f64 #s(literal 1 binary64) (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))) (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a))))))
(pow.f64 (/.f64 (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))) (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))) (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a)))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a))) #s(approx (+ t a) (+.f64 t a))))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a)))) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))))
(/.f64 (neg.f64 (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))) (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))) (neg.f64 (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))))
(/.f64 (neg.f64 (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a))) #s(approx (+ t a) (+.f64 t a))))) (neg.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))) (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a))))))
(/.f64 (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))) (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))) (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
(/.f64 (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a))) #s(approx (+ t a) (+.f64 t a)))) (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a))) (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))))))
(/.f64 (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a))) #s(approx (+ t a) (+.f64 t a)))) (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))) (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) (*.f64 (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))) (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a))) (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a)))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a))) #s(approx (+ t a) (+.f64 t a))))))
(-.f64 (/.f64 (*.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ t a) (+.f64 t a))) (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))) (/.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) (-.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))))
(+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ t a) (+.f64 t a)))
(+.f64 #s(approx (+ t a) (+.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)))
#s(approx (+ t a) (+.f64 t a))
(*.f64 (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)))
(*.f64 (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 z z))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 z (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))) (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 z z) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))) (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 z z))) (neg.f64 (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)))
(/.f64 (neg.f64 (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 z (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 z z)) (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
(/.f64 (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))))
(/.f64 (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64))) (fma.f64 z (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 z z))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 z (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))) (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)))))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) z) #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) z z)
(fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)
(fma.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z)
(fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)
(fma.f64 z (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z)
(fma.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (/.f64 #s(literal 1 binary64) z)) z)
(fma.f64 z #s(literal 1 binary64) #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)))
(fma.f64 #s(literal 1 binary64) #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
(-.f64 (/.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)) (/.f64 (*.f64 z z) (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)))
(+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
(+.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
(*.f64 (*.f64 (/.f64 #s(literal 1 binary64) z) #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) z)
(*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64))
(*.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
(*.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z))
(*.f64 z (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
(*.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (/.f64 #s(literal 1 binary64) z)))
(*.f64 #s(literal 1 binary64) #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)))
(pow.f64 (/.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)) #s(literal -1 binary64))
#s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))
(/.f64 (*.f64 #s(literal -1 binary64) (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)) (neg.f64 z))
(/.f64 (*.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #s(literal -1 binary64)) (neg.f64 z))
(/.f64 (neg.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)) (neg.f64 z))
(/.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z)
(/.f64 #s(literal 1 binary64) (/.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)))
(*.f64 (log.f64 y) x)
(*.f64 x (log.f64 y))
(*.f64 (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 z z)) (/.f64 #s(literal 1 binary64) (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)))
(*.f64 (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 z (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 z z))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 z (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))) (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (*.f64 z z) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))) (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))))
(/.f64 (neg.f64 (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 z z))) (neg.f64 (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)))
(/.f64 (neg.f64 (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)))) (neg.f64 (fma.f64 z (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)))))
(/.f64 (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 z z)) (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
(/.f64 (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64))) (fma.f64 z z (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))))
(/.f64 (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64))) (fma.f64 z (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (-.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (*.f64 z z))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 z (-.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64))) (fma.f64 (*.f64 z z) z (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 3 binary64)))))
(fma.f64 (*.f64 (/.f64 #s(literal 1 binary64) z) #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x))) z z)
(fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z)
(fma.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z)
(fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z)
(fma.f64 z (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z)
(fma.f64 z (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (/.f64 #s(literal 1 binary64) z)) z)
(fma.f64 z #s(literal 1 binary64) #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)))
(fma.f64 #s(literal 1 binary64) #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
(-.f64 (/.f64 (pow.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 2 binary64)) (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)) (/.f64 (*.f64 z z) (-.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)))
(+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
(+.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
(*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) (*.f64 #s(literal 1 binary64) z))
(*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)
(*.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z))
(*.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) #s(literal 1 binary64))
(*.f64 z #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)))
(*.f64 #s(literal 1 binary64) (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
(/.f64 (*.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z) z)
(*.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a)))
(*.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (/.f64 #s(literal 1 binary64) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))))
(pow.f64 (/.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))) #s(literal -1 binary64))
(/.f64 (-.f64 (/.f64 (*.f64 t t) (*.f64 a a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))))
(/.f64 (neg.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a)))) (neg.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a)))
(/.f64 (neg.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))) (neg.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)))))
(/.f64 (fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (neg.f64 a) (*.f64 a (neg.f64 t))) (*.f64 a (neg.f64 a)))
(/.f64 (fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) a (*.f64 t a)) (*.f64 a a))
(/.f64 (fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (/.f64 a t) a) (*.f64 a (/.f64 a t)))
(/.f64 (fma.f64 (neg.f64 t) a (*.f64 (neg.f64 a) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) (*.f64 (neg.f64 a) a))
(/.f64 (fma.f64 t a (*.f64 a (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) (*.f64 a a))
(/.f64 (fma.f64 #s(literal 1 binary64) a (*.f64 (/.f64 a t) (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))))) (*.f64 (/.f64 a t) a))
(/.f64 (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a))) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (+.f64 (/.f64 (*.f64 t t) (*.f64 a a)) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 (log.f64 c) (*.f64 (-.f64 b #s(literal 1/2 binary64)) t)) (*.f64 a a)))))
(/.f64 (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64))) (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a) (-.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (*.f64 t t) (*.f64 a a)))))
(/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 (/.f64 t a) (-.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)))) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64))) (+.f64 (/.f64 (*.f64 (*.f64 t t) t) (*.f64 (*.f64 a a) a)) (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 3 binary64)))))
(fma.f64 (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 t)) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) (neg.f64 a)) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)) (/.f64 #s(literal 1 binary64) a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) (neg.f64 a)) (pow.f64 (/.f64 #s(literal 1 binary64) (neg.f64 t)) #s(literal -1 binary64)) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) (neg.f64 a)) (neg.f64 t) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (*.f64 t #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (neg.f64 t) (/.f64 #s(literal 1 binary64) (neg.f64 a)) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (/.f64 #s(literal 1 binary64) a) (/.f64 t a))
(fma.f64 t (/.f64 #s(literal 1 binary64) a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))
(fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a) (/.f64 t a))
(fma.f64 (log.f64 c) (*.f64 (/.f64 #s(literal 1 binary64) a) (-.f64 b #s(literal 1/2 binary64))) (/.f64 t a))
(fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a))
(fma.f64 (/.f64 #s(literal 1 binary64) a) (pow.f64 (/.f64 #s(literal 1 binary64) t) #s(literal -1 binary64)) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 (/.f64 #s(literal 1 binary64) a) t (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(fma.f64 #s(literal 1 binary64) (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
(-.f64 (/.f64 (pow.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) #s(literal 2 binary64)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a)) (/.f64 (/.f64 (*.f64 t t) (*.f64 a a)) (/.f64 (fma.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64)) (neg.f64 t)) a)))
(+.f64 (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))) (/.f64 t a))
(+.f64 (/.f64 t a) (*.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64))))
#s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))

eval280.0ms (2.1%)

Memory
29.4MiB live, 532.2MiB allocated
Compiler

Compiled 50 385 to 2 124 computations (95.8% saved)

prune452.0ms (3.3%)

Memory
-35.0MiB live, 647.5MiB allocated
Pruning

47 alts after pruning (41 fresh and 6 done)

PrunedKeptTotal
New1 906161 922
Fresh62531
Picked235
Done033
Total1 914471 961
Accuracy
100.0%
Counts
1 961 → 47
Alt Table
Click to see full alt table
StatusAccuracyProgram
37.4%
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
66.5%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #s(approx (+ (+ (* (- b 1/2) (/ (log c) a)) (/ t a)) (/ z a)) (/.f64 z a))) a a)) (*.f64 y i))
60.2%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
32.8%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
35.6%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
33.5%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (*.f64 (/.f64 (log.f64 c) x) b)) x)) (*.f64 y i))
44.2%
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.f64 y i))
63.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i #s(approx (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t)) (*.f64 (log.f64 y) x))) a) z) z z))
18.1%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (*.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z) z) (/.f64 #s(literal 1 binary64) z) z))
25.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z) #s(literal 1 binary64) z))
41.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
32.4%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 (log.f64 y) x)) a) a a))
40.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 i y)) a) a a))
25.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
25.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)) z) (/.f64 #s(literal 1 binary64) z) z))
✓25.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z))
34.6%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) z) (/.f64 #s(literal 1 binary64) z) z))
21.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
34.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
33.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (/.f64 (log.f64 c) z) b)) z z))
35.4%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 z a)) a a))
✓22.7%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
22.7%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (/.f64 #s(literal 1 binary64) a) t)) a a))
37.1%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 b (/.f64 (log.f64 c) a))) a a))
71.4%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (+.f64 (+.f64 y (/.f64 a i)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 t i)))) i)) #s(literal 1 binary64) z))
43.4%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
28.9%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 (log.f64 c) z) b)) (/.f64 #s(literal 1 binary64) z) z))
31.9%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 y z) i)) (/.f64 #s(literal 1 binary64) z) z))
15.1%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z t)) (/.f64 #s(literal 1 binary64) z) z))
32.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z a)) (/.f64 #s(literal 1 binary64) z) z))
5.3%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 (-.f64 (*.f64 a a) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))))
13.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
25.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
25.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a)))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
76.5%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
72.3%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) z z))))
66.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))))
62.7%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
✓45.1%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
42.6%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
32.9%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
✓36.2%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
38.8%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
✓14.9%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
✓24.4%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
22.0%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
50.6%
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ t a) (+ (* (- b 1/2) (log c)) (+ (* y i) z))) (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (fma.f64 i (/.f64 y t) (/.f64 z t))) (/.f64 a t)) t t)))
Compiler

Compiled 2 282 to 926 computations (59.4% saved)

regimes272.0ms (2%)

Memory
-20.5MiB live, 561.3MiB allocated
Counts
73 → 1
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 z a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z a)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z t)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (/.f64 #s(literal 1 binary64) a) t)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 i y)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 y z) i)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a)))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 (-.f64 (*.f64 a a) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 b (/.f64 (log.f64 c) a))) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (/.f64 (log.f64 c) z) b)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 (log.f64 y) x)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) 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)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 (log.f64 c) z) b)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z) #s(literal 1 binary64) z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 #s(approx (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (*.f64 (/.f64 (log.f64 c) x) b)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i #s(approx (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t)) (*.f64 (log.f64 y) x))) a) z) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (*.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z) z) (/.f64 #s(literal 1 binary64) z) z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #s(approx (+ (+ (* (- b 1/2) (/ (log c) a)) (/ t a)) (/ z a)) (/.f64 z a))) a a)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) z z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ t a) (+ (* (- b 1/2) (log c)) (+ (* y i) z))) (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (fma.f64 i (/.f64 y t) (/.f64 z t))) (/.f64 a t)) t t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ t a) (+ (* (- b 1/2) (log c)) (+ (* y i) z))) (fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 y i) t)) (/.f64 z t)) (/.f64 a t)) t t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) 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 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))) 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 y i z) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) t))) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) 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 y i (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))) a) t) t 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)) t))) a) z) (/.f64 #s(literal 1 binary64) z) z))
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (/.f64 (*.f64 (fma.f64 b b #s(literal -1/4 binary64)) (log.f64 c)) (+.f64 #s(literal 1/2 binary64) b))) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 #s(approx (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (*.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) x) (log.f64 c))) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 #s(approx (+ (+ (* (/ x a) (log y)) (/ z a)) (+ (* (/ (log c) a) (- b 1/2)) (/ t a))) (+.f64 (fma.f64 x (/.f64 (log.f64 y) a) (*.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) a))) (/.f64 z a))) a a)) (*.f64 y i))
(+.f64 (+.f64 #s(approx (+ (+ (+ (* x (log y)) z) t) a) (fma.f64 (+.f64 (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)) (/.f64 a t)) t t)) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) #s(approx (* (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) x) (*.f64 (neg.f64 a) (fma.f64 x (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 t x)) (log.f64 y)) (neg.f64 a)) #s(literal -1 binary64))))) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 c) x) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z x)) (/.f64 t x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (+.f64 (+.f64 y (/.f64 a i)) (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) i) (fma.f64 x (/.f64 (log.f64 y) i) (/.f64 t i)))) i)) #s(literal 1 binary64) z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x a) (log.f64 y) (/.f64 z a)) (fma.f64 (/.f64 (log.f64 c) a) (-.f64 b #s(literal 1/2 binary64)) (/.f64 t a))) a a)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (+.f64 (fma.f64 (/.f64 x t) (log.f64 y) (/.f64 z t)) (fma.f64 (/.f64 (log.f64 c) t) (-.f64 b #s(literal 1/2 binary64)) (/.f64 a t))) t t)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (/.f64 (log.f64 c) a) (/.f64 t a)) (/.f64 z a))) a a)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (+.f64 (+.f64 (/.f64 a i) y) (/.f64 t i)) (fma.f64 (/.f64 x i) (log.f64 y) (fma.f64 (/.f64 (log.f64 c) i) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z i)))) i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (log.f64 y) y) x i) (+.f64 (/.f64 t y) (/.f64 a y))) (fma.f64 (/.f64 (log.f64 c) y) (-.f64 b #s(literal 1/2 binary64)) (/.f64 z y))) y))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (*.f64 (-.f64 (/.f64 (+.f64 (+.f64 (/.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z) x) (/.f64 a x)) (log.f64 y)) (neg.f64 t)) (/.f64 #s(literal 1 binary64) x)) (neg.f64 t))) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 (/.f64 (+.f64 (+.f64 t a) (fma.f64 #s(literal -1/2 binary64) (log.f64 c) (fma.f64 (log.f64 y) x z))) b) (log.f64 c)) b)) (*.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))
Calls

12 calls:

36.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))
27.0ms
a
23.0ms
y
21.0ms
(log.f64 c)
20.0ms
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
Results
AccuracySegmentsBranch
99.9%1x
99.9%1y
99.9%1z
99.9%1t
99.9%1a
99.9%1b
99.9%1c
99.9%1i
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(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
99.9%1(-.f64 b #s(literal 1/2 binary64))
99.9%1(log.f64 c)
Compiler

Compiled 136 to 115 computations (15.4% saved)

regimes315.0ms (2.3%)

Memory
23.5MiB live, 311.6MiB allocated
Counts
53 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 z a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z a)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z t)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (/.f64 #s(literal 1 binary64) a) t)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 i y)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 y z) i)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a)))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 (-.f64 (*.f64 a a) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 b (/.f64 (log.f64 c) a))) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (/.f64 (log.f64 c) z) b)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 (log.f64 y) x)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) 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)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 (log.f64 c) z) b)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z) #s(literal 1 binary64) z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 #s(approx (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (*.f64 (/.f64 (log.f64 c) x) b)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i #s(approx (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t)) (*.f64 (log.f64 y) x))) a) z) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (*.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z) z) (/.f64 #s(literal 1 binary64) z) z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #s(approx (+ (+ (* (- b 1/2) (/ (log c) a)) (/ t a)) (/ z a)) (/.f64 z a))) a a)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) z z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ t a) (+ (* (- b 1/2) (log c)) (+ (* y i) z))) (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (fma.f64 i (/.f64 y t) (/.f64 z t))) (/.f64 a t)) t t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ t a) (+ (* (- b 1/2) (log c)) (+ (* y i) z))) (fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 y i) t)) (/.f64 z t)) (/.f64 a t)) t t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
Calls

12 calls:

101.0ms
i
37.0ms
a
31.0ms
b
25.0ms
y
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))
Results
AccuracySegmentsBranch
94.4%3x
91.0%2y
85.8%1z
85.8%1t
89.7%3a
85.8%1b
85.8%1c
95.5%3i
85.8%1(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
85.8%1(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
85.8%1(-.f64 b #s(literal 1/2 binary64))
85.8%1(log.f64 c)
Compiler

Compiled 136 to 115 computations (15.4% saved)

regimes41.0ms (0.3%)

Memory
2.8MiB live, 41.1MiB allocated
Counts
52 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 z a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z a)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z t)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (/.f64 #s(literal 1 binary64) a) t)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 i y)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 y z) i)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a)))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 (-.f64 (*.f64 a a) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 b (/.f64 (log.f64 c) a))) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (/.f64 (log.f64 c) z) b)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 (log.f64 y) x)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) 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)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 (log.f64 c) z) b)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z) #s(literal 1 binary64) z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 #s(approx (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (*.f64 (/.f64 (log.f64 c) x) b)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (+.f64 (fma.f64 y i #s(approx (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t)) (*.f64 (log.f64 y) x))) a) z) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (*.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z) z) (/.f64 #s(literal 1 binary64) z) z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (fma.f64 (fma.f64 x (*.f64 (/.f64 #s(literal 1 binary64) a) (log.f64 y)) #s(approx (+ (+ (* (- b 1/2) (/ (log c) a)) (/ t a)) (/ z a)) (/.f64 z a))) a a)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) z) (log.f64 c) (/.f64 (*.f64 y i) z)) z z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (*.f64 (/.f64 #s(literal 1 binary64) z) (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ t a) (+ (* (- b 1/2) (log c)) (+ (* y i) z))) (fma.f64 (+.f64 (fma.f64 (log.f64 c) (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (fma.f64 i (/.f64 y t) (/.f64 z t))) (/.f64 a t)) t t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) #s(approx (+ (+ t a) (+ (* (- b 1/2) (log c)) (+ (* y i) z))) (fma.f64 (+.f64 (+.f64 (fma.f64 (/.f64 (-.f64 b #s(literal 1/2 binary64)) t) (log.f64 c) (/.f64 (*.f64 y i) t)) (/.f64 z t)) (/.f64 a t)) t t)))
Outputs
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 #s(approx (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
Calls

2 calls:

24.0ms
i
14.0ms
x
Results
AccuracySegmentsBranch
93.6%3x
85.8%1i
Compiler

Compiled 18 to 16 computations (11.1% saved)

regimes18.0ms (0.1%)

Memory
-8.1MiB live, 29.6MiB allocated
Counts
43 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 z a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z a)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z t)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (/.f64 #s(literal 1 binary64) a) t)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 i y)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 y z) i)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a)))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 (-.f64 (*.f64 a a) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 b (/.f64 (log.f64 c) a))) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (/.f64 (log.f64 c) z) b)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 (log.f64 y) x)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) 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)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 (log.f64 c) z) b)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z) z) #s(literal 1 binary64) z))
Outputs
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
Calls

1 calls:

15.0ms
x
Results
AccuracySegmentsBranch
93.2%3x
Compiler

Compiled 9 to 8 computations (11.1% saved)

regimes182.0ms (1.3%)

Memory
-17.1MiB live, 141.3MiB allocated
Counts
35 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 z a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z a)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z t)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (/.f64 #s(literal 1 binary64) a) t)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 i y)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 y z) i)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a)))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 (-.f64 (*.f64 a a) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (*.f64 i y)))))
Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))))
Calls

12 calls:

27.0ms
t
27.0ms
(-.f64 b #s(literal 1/2 binary64))
26.0ms
y
17.0ms
z
10.0ms
a
Results
AccuracySegmentsBranch
73.9%2t
77.3%2(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
77.6%2z
66.0%1b
70.5%3c
72.2%4(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
66.0%1(-.f64 b #s(literal 1/2 binary64))
70.5%3(log.f64 c)
81.3%3i
71.6%3a
73.4%2y
80.1%6x
Compiler

Compiled 136 to 115 computations (15.4% saved)

regimes30.0ms (0.2%)

Memory
28.9MiB live, 28.9MiB allocated
Counts
33 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 z a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z a)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z t)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (/.f64 #s(literal 1 binary64) a) t)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 i y)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 y z) i)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a)))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 (-.f64 (*.f64 a a) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.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))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
Outputs
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z))))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.f64 y i))
Calls

3 calls:

9.0ms
i
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
z
Results
AccuracySegmentsBranch
73.3%3(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
68.3%3z
78.2%3i
Compiler

Compiled 47 to 36 computations (23.4% saved)

regimes119.0ms (0.9%)

Memory
-0.3MiB live, 81.5MiB allocated
Counts
32 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 z a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z a)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z t)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (/.f64 #s(literal 1 binary64) a) t)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 i y)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 y z) i)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a)))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 (-.f64 (*.f64 a a) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.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
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
(fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))
Calls

6 calls:

43.0ms
i
38.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
t
9.0ms
x
9.0ms
a
Results
AccuracySegmentsBranch
67.2%4a
70.9%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))
57.4%4y
59.9%5x
61.2%4t
62.7%4i
Compiler

Compiled 74 to 60 computations (18.9% saved)

regimes76.0ms (0.6%)

Memory
-6.6MiB live, 66.7MiB allocated
Counts
29 → 3
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 z a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z a)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z t)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (/.f64 #s(literal 1 binary64) a) t)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 i y)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 y z) i)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a)))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 (-.f64 (*.f64 a a) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) #s(literal 1 binary64) z))
Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
Calls

4 calls:

36.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))
22.0ms
c
8.0ms
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
8.0ms
(log.f64 c)
Results
AccuracySegmentsBranch
53.9%4c
53.9%4(log.f64 c)
59.6%3(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
70.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 62 to 49 computations (21% saved)

regimes55.0ms (0.4%)

Memory
-1.8MiB live, 45.6MiB allocated
Counts
27 → 2
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 z a)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 a z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (/.f64 t z)) z z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z a)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 z t)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (/.f64 #s(literal 1 binary64) a) t)) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) (*.f64 i y)) a) a a))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (/.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 y i)) z) z z))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 a x)) x)) (*.f64 y i))
(+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 #s(approx (+ (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (log y)) (/.f64 z x)) x)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (/.f64 a t) t t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (* (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) z) (*.f64 (*.f64 y z) i)) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) z) (/.f64 #s(literal 1 binary64) z) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ t a) (fma.f64 (*.f64 t a) (/.f64 #s(literal 1 binary64) t) t)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (/.f64 #s(literal 1 binary64) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 #s(literal 1 binary64) (/.f64 (-.f64 t a) (*.f64 (+.f64 t a) (-.f64 t a)))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (fma.f64 (*.f64 t t) t (*.f64 (*.f64 a a) a)) (fma.f64 a (-.f64 a t) (*.f64 t t))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 (-.f64 (*.f64 a a) (*.f64 (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) (*.f64 a a)) #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)))) (-.f64 a (*.f64 #s(approx (/ (+ (+ (* y i) z) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (/.f64 t a)) a))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (/.f64 #s(literal 1 binary64) (/.f64 (fma.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (-.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 t a)) (*.f64 (+.f64 t a) (+.f64 t a))) (fma.f64 (*.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y))) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (*.f64 (*.f64 (+.f64 t a) (+.f64 t a)) (+.f64 t a))))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 b (log.f64 c)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 (log.f64 y) x))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 (log.f64 y) x)) z))
Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
Calls

4 calls:

29.0ms
(-.f64 b #s(literal 1/2 binary64))
8.0ms
b
8.0ms
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
8.0ms
z
Results
AccuracySegmentsBranch
59.1%2z
57.6%4b
56.0%3(-.f64 b #s(literal 1/2 binary64))
64.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 58 to 46 computations (20.7% saved)

regimes39.0ms (0.3%)

Memory
4.2MiB live, 42.8MiB allocated
Counts
2 → 1
Calls
Call 1
Inputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
Calls

12 calls:

20.0ms
t
2.0ms
(+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i))
2.0ms
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
2.0ms
(log.f64 c)
2.0ms
y
Results
AccuracySegmentsBranch
45.1%1c
45.1%1(log.f64 c)
45.1%1y
45.1%1(-.f64 b #s(literal 1/2 binary64))
45.1%1b
45.1%1x
45.1%1(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
45.1%1t
45.1%1z
45.1%1i
45.1%1a
45.1%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 136 to 115 computations (15.4% saved)

regimes41.0ms (0.3%)

Memory
4.0MiB live, 42.1MiB allocated
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)) (*.f64 y i))
Outputs
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
Calls

12 calls:

26.0ms
(*.f64 (-.f64 b #s(literal 1/2 binary64)) (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
(log.f64 c)
1.0ms
i
1.0ms
t
Results
AccuracySegmentsBranch
24.4%1x
24.4%1z
24.4%1y
24.4%1t
24.4%1b
24.4%1(-.f64 b #s(literal 1/2 binary64))
24.4%1a
24.4%1c
24.4%1i
24.4%1(*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))
24.4%1(log.f64 c)
24.4%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 136 to 115 computations (15.4% saved)

bsearch77.0ms (0.6%)

Memory
-25.9MiB live, 54.5MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
38.0ms
1.842450799667507e-24
6.783076190735082e-23
35.0ms
-1.4854914302615707e+32
-2.764522170018821e+31
Samples
64.0ms208×0valid
Compiler

Compiled 669 to 460 computations (31.2% saved)

Precisions
Click to see histograms. Total time spent on operations: 57.0ms
ival-log: 26.0ms (46% of total)
ival-add: 25.0ms (44.2% of total)
ival-mult: 4.0ms (7.1% of total)
ival-sub: 1.0ms (1.8% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

bsearch75.0ms (0.6%)

Memory
27.4MiB live, 64.6MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
56.0ms
5.902397490861588e+246
4.95364672769483e+251
14.0ms
-3.997253296906334e+221
-2.6145175698460825e+220
Samples
61.0ms240×0valid
Compiler

Compiled 683 to 469 computations (31.3% saved)

Precisions
Click to see histograms. Total time spent on operations: 52.0ms
ival-log: 41.0ms (78.3% of total)
ival-add: 5.0ms (9.5% of total)
ival-mult: 5.0ms (9.5% of total)
ival-sub: 1.0ms (1.9% of total)
ival-true: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

bsearch27.0ms (0.2%)

Memory
-22.7MiB live, 13.2MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
1.0ms
5.902397490861588e+246
4.95364672769483e+251
26.0ms
-3.997253296906334e+221
-2.6145175698460825e+220
Samples
2.0ms16×0valid
Compiler

Compiled 647 to 451 computations (30.3% saved)

Precisions
Click to see histograms. Total time spent on operations: 1.0ms
ival-sub: 0.0ms (0% of total)
ival-true: 0.0ms (0% of total)
ival-log: 0.0ms (0% of total)
ival-add: 0.0ms (0% of total)
ival-mult: 0.0ms (0% of total)
exact: 0.0ms (0% of total)
ival-assert: 0.0ms (0% of total)

bsearch50.0ms (0.4%)

Memory
26.0MiB live, 62.5MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
37.0ms
1.274974464437445e+84
9.207224426731519e+86
10.0ms
-1.4854914302615707e+32
-2.764522170018821e+31
Samples
21.0ms191×0valid
0.0ms1×1valid
Compiler

Compiled 676 to 465 computations (31.2% saved)

Precisions
Click to see histograms. Total time spent on operations: 14.0ms
ival-log: 5.0ms (35.8% of total)
ival-add: 4.0ms (28.7% of total)
ival-mult: 4.0ms (28.7% of total)
ival-sub: 1.0ms (7.2% 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)

bsearch49.0ms (0.4%)

Memory
1.1MiB live, 50.0MiB allocated
Algorithm
2×binary-search
Stop Event
1×narrow-enough
1×narrow-enough
Steps
TimeLeftRight
5.0ms
1.274974464437445e+84
9.207224426731519e+86
41.0ms
-1.2829714977573708e+111
-4.985385990105595e+107
Samples
40.0ms159×0valid
0.0ms1×1valid
Compiler

Compiled 672 to 479 computations (28.7% saved)

Precisions
Click to see histograms. Total time spent on operations: 34.0ms
ival-log: 26.0ms (77% of total)
ival-add: 3.0ms (8.9% of total)
ival-mult: 3.0ms (8.9% of total)
ival-sub: 1.0ms (3% 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)

bsearch1.0ms (0%)

Memory
1.1MiB live, 1.1MiB allocated
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
4.3521632949940543e+307
1.6352550201217028e+308
0.0ms
1.1785552676932873e+114
1.846609173433753e+114
Compiler

Compiled 32 to 31 computations (3.1% saved)

bsearch1.0ms (0%)

Memory
0.8MiB live, 0.8MiB allocated
Algorithm
2×left-value
Steps
TimeLeftRight
0.0ms
4.3521632949940543e+307
1.6352550201217028e+308
0.0ms
1.1785552676932873e+114
1.846609173433753e+114
Compiler

Compiled 32 to 31 computations (3.1% saved)

bsearch0.0ms (0%)

Memory
0.7MiB live, 0.7MiB allocated
Algorithm
1×left-value
Steps
TimeLeftRight
0.0ms
-127.55774515062565
302.6278729686127
Compiler

Compiled 32 to 31 computations (3.1% saved)

simplify27.0ms (0.2%)

Memory
-15.4MiB live, 23.7MiB allocated
Algorithm
1×egg-herbie
Rules
42×+-commutative_binary64
16×*-commutative_binary64
8×sub-neg_binary64
4×neg-sub0_binary64
4×neg-mul-1_binary64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
01311142
11611142
21681142
31721142
41741142
Stop Event
1×saturated
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))
(if (<=.f64 i #s(literal -28000000000000001682669402324992 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (if (<=.f64 i #s(literal 3811162509514511/680564733841876926926749214863536422912 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))))
(if (<=.f64 x #s(literal -54999999999999998549934186524643441914600670718992563353541648867194957530355727411612580085262802970330714936542895769662327888808863195516600381908875889165311303907759116786973267936437664731746974093288232427165057024 binary64)) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 #s(approx (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (if (<=.f64 x #s(literal 6300000000000000024556127437290828952647577570464758661219607900142661291204266458504818811897006917964674737529646255490432529236201625902748087206814729248175301566592832524354567842035300836407684573388043528613480442988191962756637001005400064 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))))
(if (<=.f64 x #s(literal -60000000000000004802691034534489316278144673011074193697564965643037264600592187506810884776110723342925115483877282478384096451371171985235754242576168356468744484190760611022718496547598500987691739833367405030048530432 binary64)) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))) (if (<=.f64 x #s(literal 6300000000000000024556127437290828952647577570464758661219607900142661291204266458504818811897006917964674737529646255490432529236201625902748087206814729248175301566592832524354567842035300836407684573388043528613480442988191962756637001005400064 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))))
(if (<=.f64 i #s(literal -53000000000000003024209953423360 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))))) (if (<=.f64 i #s(literal 28999999999999999734115527010514939154655660420372451473968815610885439047030875881472 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))))))
(if (<=.f64 i #s(literal -800000000000000018855494011336204666599626236045505490503930031414625334772929386078647489273959608209851285504 binary64)) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.f64 y i)) (if (<=.f64 i #s(literal 32999999999999999102463673254158052535060246144128526465972361542525968987783046365184 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.f64 y i))))
(if (<=.f64 (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) #s(literal 1500000000000000023339124194200264536402302095381592150054655870646250671747133554897478084872571171514309421301760 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z)) (if (<=.f64 (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) #s(literal 50000000000000000548953181472022770870246154838655923168405341451578792702455745768581664489247344449530624834860586257805795141871570044164153504599073023015635832251466513592848744849794279521669192233082500589213448813106472588814045597893353729061391985085892207552645901446603936636487442857715111559168 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c))))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))))
(if (<=.f64 (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) #s(literal 1500000000000000023339124194200264536402302095381592150054655870646250671747133554897478084872571171514309421301760 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z)) (if (<=.f64 (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) #s(literal 50000000000000000548953181472022770870246154838655923168405341451578792702455745768581664489247344449530624834860586257805795141871570044164153504599073023015635832251466513592848744849794279521669192233082500589213448813106472588814045597893353729061391985085892207552645901446603936636487442857715111559168 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c))))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))))
(if (<=.f64 (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) #s(literal -100 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.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))
(+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 y) x))))))
(if (<=.f64 i #s(literal -28000000000000001682669402324992 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (if (<=.f64 i #s(literal 3811162509514511/680564733841876926926749214863536422912 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z))))))
(if (<=.f64 i #s(literal -28000000000000001682669402324992 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (+.f64 a t))) (if (<=.f64 i #s(literal 3811162509514511/680564733841876926926749214863536422912 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (fma.f64 (log.f64 y) x (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) (+.f64 a t))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (+.f64 a t)))))
(if (<=.f64 x #s(literal -54999999999999998549934186524643441914600670718992563353541648867194957530355727411612580085262802970330714936542895769662327888808863195516600381908875889165311303907759116786973267936437664731746974093288232427165057024 binary64)) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 #s(approx (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 y i)) (if (<=.f64 x #s(literal 6300000000000000024556127437290828952647577570464758661219607900142661291204266458504818811897006917964674737529646255490432529236201625902748087206814729248175301566592832524354567842035300836407684573388043528613480442988191962756637001005400064 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))))
(if (<=.f64 x #s(literal -54999999999999998549934186524643441914600670718992563353541648867194957530355727411612580085262802970330714936542895769662327888808863195516600381908875889165311303907759116786973267936437664731746974093288232427165057024 binary64)) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (+.f64 #s(approx (+ (+ (+ (* (/ (log c) x) (- b 1/2)) (/ z x)) (/ t x)) (/ a x)) (/.f64 a x)) (log.f64 y)) x)) (*.f64 i y)) (if (<=.f64 x #s(literal 6300000000000000024556127437290828952647577570464758661219607900142661291204266458504818811897006917964674737529646255490432529236201625902748087206814729248175301566592832524354567842035300836407684573388043528613480442988191962756637001005400064 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (+.f64 a t))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))))
(if (<=.f64 x #s(literal -60000000000000004802691034534489316278144673011074193697564965643037264600592187506810884776110723342925115483877282478384096451371171985235754242576168356468744484190760611022718496547598500987691739833367405030048530432 binary64)) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))) (if (<=.f64 x #s(literal 6300000000000000024556127437290828952647577570464758661219607900142661291204266458504818811897006917964674737529646255490432529236201625902748087206814729248175301566592832524354567842035300836407684573388043528613480442988191962756637001005400064 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))))
(if (<=.f64 x #s(literal -60000000000000004802691034534489316278144673011074193697564965643037264600592187506810884776110723342925115483877282478384096451371171985235754242576168356468744484190760611022718496547598500987691739833367405030048530432 binary64)) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x))) (if (<=.f64 x #s(literal 6300000000000000024556127437290828952647577570464758661219607900142661291204266458504818811897006917964674737529646255490432529236201625902748087206814729248175301566592832524354567842035300836407684573388043528613480442988191962756637001005400064 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) (fma.f64 y i z)) (+.f64 a t))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))))
(if (<=.f64 i #s(literal -53000000000000003024209953423360 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i))))) (if (<=.f64 i #s(literal 28999999999999999734115527010514939154655660420372451473968815610885439047030875881472 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 y i)))))))
(if (<=.f64 i #s(literal -53000000000000003024209953423360 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 i y))) (+.f64 a t))) (if (<=.f64 i #s(literal 28999999999999999734115527010514939154655660420372451473968815610885439047030875881472 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) (+.f64 a t))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (+.f64 #s(literal -1/2 binary64) b) (log.f64 c) (*.f64 i y))) (+.f64 a t)))))
(if (<=.f64 i #s(literal -800000000000000018855494011336204666599626236045505490503930031414625334772929386078647489273959608209851285504 binary64)) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.f64 y i)) (if (<=.f64 i #s(literal 32999999999999999102463673254158052535060246144128526465972361542525968987783046365184 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)))) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 b (log.f64 c))) (*.f64 y i))))
(if (<=.f64 i #s(literal -800000000000000018855494011336204666599626236045505490503930031414625334772929386078647489273959608209851285504 binary64)) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 c) b)) (*.f64 i y)) (if (<=.f64 i #s(literal 32999999999999999102463673254158052535060246144128526465972361542525968987783046365184 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (fma.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c) z)) (+.f64 a t))) (+.f64 #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 c) b)) (*.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 1500000000000000023339124194200264536402302095381592150054655870646250671747133554897478084872571171514309421301760 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z)) (if (<=.f64 (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) #s(literal 50000000000000000548953181472022770870246154838655923168405341451578792702455745768581664489247344449530624834860586257805795141871570044164153504599073023015635832251466513592848744849794279521669192233082500589213448813106472588814045597893353729061391985085892207552645901446603936636487442857715111559168 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c))))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))))
(if (<=.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 y) x)))))) #s(literal 1500000000000000023339124194200264536402302095381592150054655870646250671747133554897478084872571171514309421301760 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z)) (if (<=.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 y) x)))))) #s(literal 50000000000000000548953181472022770870246154838655923168405341451578792702455745768581664489247344449530624834860586257805795141871570044164153504599073023015635832251466513592848744849794279521669192233082500589213448813106472588814045597893353729061391985085892207552645901446603936636487442857715111559168 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 (log.f64 c) b)) (+.f64 a t))) (fma.f64 y i #s(approx (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (*.f64 (log.f64 y) x)))))
(if (<=.f64 (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) #s(literal 1500000000000000023339124194200264536402302095381592150054655870646250671747133554897478084872571171514309421301760 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z)) (if (<=.f64 (+.f64 (+.f64 (+.f64 (+.f64 (+.f64 (*.f64 x (log.f64 y)) z) t) a) (*.f64 (-.f64 b #s(literal 1/2 binary64)) (log.f64 c))) (*.f64 y i)) #s(literal 50000000000000000548953181472022770870246154838655923168405341451578792702455745768581664489247344449530624834860586257805795141871570044164153504599073023015635832251466513592848744849794279521669192233082500589213448813106472588814045597893353729061391985085892207552645901446603936636487442857715111559168 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 b (log.f64 c))))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (/.f64 (*.f64 (+.f64 t a) (-.f64 t a)) (-.f64 t a)) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))))
(if (<=.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 y) x)))))) #s(literal 1500000000000000023339124194200264536402302095381592150054655870646250671747133554897478084872571171514309421301760 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z)) (if (<=.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 y) x)))))) #s(literal 50000000000000000548953181472022770870246154838655923168405341451578792702455745768581664489247344449530624834860586257805795141871570044164153504599073023015635832251466513592848744849794279521669192233082500589213448813106472588814045597893353729061391985085892207552645901446603936636487442857715111559168 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 (log.f64 c) b)) (+.f64 a t))) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (/.f64 (*.f64 (-.f64 t a) (+.f64 a t)) (-.f64 t 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 -100 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i)))))
(if (<=.f64 (+.f64 (*.f64 i y) (+.f64 (*.f64 (log.f64 c) (-.f64 b #s(literal 1/2 binary64))) (+.f64 a (+.f64 t (+.f64 z (*.f64 (log.f64 y) x)))))) #s(literal -100 binary64)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (fma.f64 #s(approx (+ (+ (* y i) (+ (* (log y) x) (+ (* (- b 1/2) (log c)) t))) a) (*.f64 i y)) #s(literal 1 binary64) z)) #s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 a t))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 (+.f64 t a) #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 y i))))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (+.f64 #s(approx (+ (* (- b 1/2) (log c)) (+ (* y i) z)) (*.f64 i y)) (+.f64 a t)))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 y i))
#s(approx (+ (+ (+ (+ (+ (* x (log y)) z) t) a) (* (- b 1/2) (log c))) (* y i)) (*.f64 i y))

soundness1.2s (9%)

Memory
6.2MiB live, 919.4MiB allocated
Rules
9 648×lower-fma.f64
9 648×lower-fma.f32
8 690×lower-+.f64
8 690×lower-+.f32
8 512×lower-fma.f64
Iterations

Useful iterations: 0 (0.0ms)

IterNodesCost
078730133
1270329623
0836726772
058504
089504
1437504
24392500
08721472
083930460
1284330069
2750029779
0827927853
051431
079431
1405424
24389422
08915403
03404983
110744928
237634829
371654829
083364338
Stop Event
1×fuel
1×iter limit
1×node limit
1×iter limit
1×node limit
1×iter limit
1×iter limit
1×node limit
1×iter limit
1×node limit
1×iter limit
1×iter limit
1×node limit
Compiler

Compiled 1 109 to 561 computations (49.4% saved)

preprocess224.0ms (1.7%)

Memory
-12.3MiB live, 235.3MiB allocated
Remove

(sort z t a)

Compiler

Compiled 1 226 to 370 computations (69.8% saved)

end0.0ms (0%)

Memory
0.0MiB live, 0.0MiB allocated

Profiling

Loading profile data...