Metrics for math.log10 on complex, real part

start0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

analyze69.0ms (1%)

Memory

-2.8MiB live, 109.9MiB allocated

Algorithm

1×

Search

Probability	Valid	Unknown	Precondition	Infinite	Domain	Can't	Iter
0%	0%	99.9%	0.1%	0%	0%	0%	0
0%	0%	99.9%	0.1%	0%	0%	0%	1
0%	0%	99.9%	0.1%	0%	0%	0%	2
0%	0%	99.9%	0.1%	0%	0%	0%	3
0%	0%	99.9%	0.1%	0%	0%	0%	4
18.8%	18.7%	81.2%	0.1%	0%	0%	0%	5
34.4%	34.3%	65.6%	0.1%	0%	0%	0%	6
54.7%	54.6%	45.3%	0.1%	0%	0%	0%	7
64.8%	64.8%	35.1%	0.1%	0%	0%	0%	8
76.2%	76.1%	23.8%	0.1%	0%	0%	0%	9
81.8%	81.8%	18.1%	0.1%	0%	0%	0%	10
87.8%	87.7%	12.2%	0.1%	0%	0%	0%	11
90.8%	90.7%	9.2%	0.1%	0%	0%	0%	12

Compiler

Compiled 14 to 9 computations (35.7% saved)

sample998.0ms (14.1%)

Memory

47.5MiB live, 1 470.2MiB allocated

Samples

683.0ms

8 256×

valid

Precisions

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

ival-log: 210.0ms (45.6% of total)

ival-hypot: 180.0ms (39.1% of total)

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

ival-true: 7.0ms (1.5% of total)

exact: 6.0ms (1.3% of total)

ival-assert: 4.0ms (0.9% of total)

Bogosity

explain144.0ms (2%)

Memory

-18.5MiB live, 303.8MiB allocated

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
120	-	-	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	-	`(log.f64 #s(literal 10 binary64))`
0	-	-	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
0	-	-	`(*.f64 re re)`
0	-	-	`im`
0	-	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	-	`re`
0	-	-	`(*.f64 im im)`
0	-	-	`#s(literal 10 binary64)`
0	-	-	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	oflow-rescue	106	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	106
↳	`(*.f64 re re)`	overflow	59
↳	`(*.f64 im im)`	overflow	60
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	14	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	14
↳	`(*.f64 re re)`	underflow	69
↳	`(*.f64 im im)`	underflow	69

Confusion

	Predicted +	Predicted -
+	120	0
-	0	136

Precision

1.0

Recall

1.0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	120	0	0
-	0	0	136

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	136
1	120

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

56.0ms

512×

valid

Compiler

Compiled 110 to 34 computations (69.1% saved)

Precisions

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

ival-log: 12.0ms (30.2% of total)

ival-hypot: 12.0ms (30.2% of total)

ival-mult: 7.0ms (17.6% of total)

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

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

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

exact: 0.0ms (0% of total)

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

preprocess21.0ms (0.3%)

Memory

14.3MiB live, 53.2MiB allocated

Algorithm

1×	egg-herbie

Rules

54×	`sub-neg`
34×	`neg-sub0`
30×	`distribute-lft-neg-in`
28×	`unsub-neg`
28×	`neg-mul-1`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	24	62
1	50	62
2	96	62
3	173	62
4	238	62
5	260	62
6	271	62
7	282	62
8	285	62
9	286	62
0	10	12
0	17	12
1	18	12
0	18	7

Stop Event

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

Calls

Call 1

Inputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))

Outputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64)))

Symmetry

(abs im)

(abs re)

(sort re im)

Compiler

Compiled 12 to 10 computations (16.7% saved)

eval0.0ms (0%)

Memory: 0.9MiB live, 0.9MiB allocated
Compiler: Compiled 0 to 2 computations (-∞% saved)

prune1.0ms (0%)

Memory

2.5MiB live, 2.5MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	54.1%	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 12 to 10 computations (16.7% saved)

simplify9.0ms (0.1%)

Memory

-32.0MiB live, 13.9MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score
cost-diff	0	(*.f64 re re)
cost-diff	0	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
cost-diff	0	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
cost-diff	128	(+.f64 (.f64 re re) (.f64 im im))

Rules

4×	`lower-hypot.f32`
4×	`lower-hypot.f64`
4×	`lower-fma.f64`
4×	`lift-*.f64`
4×	`lower-fma.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	10	47
0	17	47
1	18	47
0	18	31

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(+.f64 (.f64 re re) (.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)

Outputs
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64)))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(log.f64 (hypot.f64 im re))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(hypot.f64 im re)
(+.f64 (.f64 re re) (.f64 im im))
(fma.f64 im im (*.f64 re re))
(*.f64 re re)
re
(*.f64 im im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)

localize33.0ms (0.5%)

Memory

23.0MiB live, 62.3MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.5947838379159783	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
accuracy	27.96047248509236	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Samples

25.0ms

256×

valid

Compiler

Compiled 49 to 12 computations (75.5% saved)

Precisions

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

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

ival-hypot: 4.0ms (22.8% of total)

ival-div: 3.0ms (17.1% of total)

ival-mult: 3.0ms (17.1% of total)

ival-add: 1.0ms (5.7% of total)

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

exact: 0.0ms (0% of total)

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

series38.0ms (0.5%)

Memory

-27.7MiB live, 11.1MiB allocated

Counts

6 → 108

Calls

Call 1

Inputs
#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())
#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())
#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 binary64)) #<representation binary64>) () ())

Outputs
#s(alt (pow im 2) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (/ (log re) (log 10)) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
25.0ms	im	@	inf	((+ (* re re) (* im im)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (* re re) (sqrt (+ (* re re) (* im im))) (log 10))
3.0ms	re	@	inf	((+ (* re re) (* im im)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (* re re) (sqrt (+ (* re re) (* im im))) (log 10))
3.0ms	im	@	0	((+ (* re re) (* im im)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (* re re) (sqrt (+ (* re re) (* im im))) (log 10))
2.0ms	re	@	0	((+ (* re re) (* im im)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (* re re) (sqrt (+ (* re re) (* im im))) (log 10))
1.0ms	im	@	-inf	((+ (* re re) (* im im)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (* re re) (sqrt (+ (* re re) (* im im))) (log 10))

simplify198.0ms (2.8%)

Memory

34.4MiB live, 195.8MiB allocated

Algorithm

1×	egg-herbie

Rules

14 804×	`lower-fma.f64`
14 804×	`lower-fma.f32`
4 746×	`lower-*.f64`
4 746×	`lower-*.f32`
3 910×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	268	1676
1	730	1632
2	2203	1630
3	5799	1618
0	8392	1506

Stop Event

1×	iter limit
1×	node limit

Counts

108 → 104

Calls

Call 1

Inputs
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))

Outputs
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (fma.f64 (.f64 re (/.f64 re (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) im) im)) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) re) (.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 re im) (fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) re) (pow.f64 im #s(literal 6 binary64))) (/.f64 re (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im)))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (*.f64 #s(literal 1/6 binary64) re) (/.f64 re (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (log.f64 im)))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (.f64 #s(literal -1/8 binary64) re) (/.f64 re (pow.f64 im #s(literal 3 binary64))) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (fma.f64 (.f64 #s(literal 1/16 binary64) re) (/.f64 re (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re) im))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) re)) (/.f64 (.f64 im im) re) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) im) (.f64 (log.f64 #s(literal 10 binary64)) re)) (/.f64 im re) (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) im) (.f64 (log.f64 #s(literal 10 binary64)) re)) (/.f64 im re) (fma.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/720 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 (/.f64 im re) re) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 (/.f64 im re) re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 (/.f64 im re) re) (fma.f64 (.f64 #s(literal 1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal 120 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re))))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) #s(literal 1 binary64) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(.f64 (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 (/.f64 im re) re) #s(literal 1 binary64))) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(.f64 (fma.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 (/.f64 im re) re) #s(literal 1 binary64)))) re)
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(fma.f64 re re (*.f64 im im))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) im) (.f64 (log.f64 #s(literal 10 binary64)) re)) (/.f64 im re) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) im) (.f64 (log.f64 #s(literal 10 binary64)) re)) (/.f64 im re) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) im) (.f64 (log.f64 #s(literal 10 binary64)) re)) (/.f64 im re) (fma.f64 (/.f64 (*.f64 #s(literal 1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (*.f64 (/.f64 (/.f64 im re) re) im) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (fma.f64 (.f64 #s(literal -1/4 binary64) im) (/.f64 im (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 (fma.f64 (.f64 #s(literal -1/4 binary64) im) (/.f64 im (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) im) im (fma.f64 (.f64 (/.f64 #s(literal 120 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (.f64 (/.f64 (.f64 im im) re) #s(literal 1/2 binary64)) #s(literal -1 binary64) (neg.f64 re))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) (fma.f64 (.f64 #s(literal -1/2 binary64) im) (/.f64 (/.f64 im re) re) #s(literal -1 binary64))) re)
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(.f64 (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/8 binary64) (fma.f64 (.f64 #s(literal -1/2 binary64) im) (/.f64 (/.f64 im re) re) #s(literal -1 binary64)))) re)
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) re)) (/.f64 (.f64 im im) re) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) im) (.f64 (log.f64 #s(literal 10 binary64)) re)) (/.f64 im re) (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) im) (.f64 (log.f64 #s(literal 10 binary64)) re)) (/.f64 im re) (fma.f64 (fma.f64 (/.f64 (*.f64 #s(literal 1/6 binary64) im) (pow.f64 re #s(literal 6 binary64))) (/.f64 im (log.f64 #s(literal 10 binary64))) (/.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 (/.f64 im re) re) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (*.f64 #s(literal 1/2 binary64) im) (/.f64 (/.f64 im re) re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (.f64 #s(literal 1/2 binary64) im) (/.f64 (/.f64 im re) re) (fma.f64 (fma.f64 (.f64 #s(literal 1/6 binary64) im) (/.f64 im (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 im #s(literal 4 binary64)) (log.f64 re)))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (*.f64 im im) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (.f64 #s(literal -1/8 binary64) im) (/.f64 im (pow.f64 re #s(literal 3 binary64))) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/16 binary64) im) (/.f64 im (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 (.f64 re re) im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (fma.f64 (.f64 re (/.f64 re (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) im) im)) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) re) (.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 re im) (fma.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (fma.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/720 binary64)) (/.f64 #s(literal 120 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) #s(literal 1 binary64) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64)))) im (fma.f64 (.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64)) #s(literal 1 binary64) im))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(.f64 (fma.f64 (pow.f64 re #s(literal 6 binary64)) (/.f64 #s(literal 1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64)))) im)
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(fma.f64 re re (*.f64 im im))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) re) (.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 re im) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) re) (.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 re im) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(fma.f64 (/.f64 (.f64 #s(literal 1/2 binary64) re) (.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 re im) (fma.f64 (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 1/720 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal 120 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))))))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (*.f64 (/.f64 (/.f64 re im) im) re) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 (/.f64 re im) im) re) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (.f64 (fma.f64 (.f64 #s(literal -1/4 binary64) re) (/.f64 re (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) re) re (fma.f64 (.f64 (/.f64 #s(literal 120 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(neg.f64 (fma.f64 (.f64 (/.f64 (.f64 re re) im) #s(literal 1/2 binary64)) #s(literal 1 binary64) im))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) (fma.f64 (.f64 #s(literal -1/2 binary64) re) (/.f64 (/.f64 re im) im) #s(literal -1 binary64))) im)
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/8 binary64) (fma.f64 #s(literal -1/16 binary64) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (.f64 #s(literal -1/2 binary64) re) (/.f64 (/.f64 re im) im) #s(literal -1 binary64)))) im)

rewrite160.0ms (2.3%)

Memory

-8.7MiB live, 187.6MiB allocated

Rules

4 802×	`lower-fma.f64`
4 802×	`lower-fma.f32`
3 340×	`lower-*.f32`
3 336×	`lower-*.f64`
3 206×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	10	41
0	17	41
1	44	41
2	251	41
3	2046	41
0	8387	25

Stop Event

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

Counts

6 → 317

Calls

Call 1

Inputs
(+.f64 (.f64 re re) (.f64 im im))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(*.f64 re re)
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(log.f64 #s(literal 10 binary64))

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval71.0ms (1%)

Memory: 4.2MiB live, 124.8MiB allocated
Compiler: Compiled 10 557 to 1 829 computations (82.7% saved)

prune32.0ms (0.4%)

Memory

-2.3MiB live, 35.5MiB allocated

Pruning

10 alts after pruning (10 fresh and 0 done)

	Pruned	Kept	Total
New	411	10	421
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	412	10	422

Accuracy

100.0%

Counts

422 → 10

Alt Table

Click to see full alt table

Status	Accuracy	Program
	71.9%	(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
	72.4%	(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1/2 binary64))
▶	99.0%	(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))))
	98.9%	(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (hypot.f64 im re)))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (hypot.f64 im re)))))
	54.1%	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
▶	99.0%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
▶	54.1%	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
▶	98.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
▶	99.0%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))))
	99.0%	(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (hypot.f64 im re))))

Compiler

Compiled 244 to 200 computations (18% saved)

simplify45.0ms (0.6%)

Memory

-27.1MiB live, 17.2MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	(log.f64 #s(literal 1/10 binary64))
cost-diff	0	(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
cost-diff	5888	(neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
cost-diff	7040	(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))))
cost-diff	0	(log.f64 (hypot.f64 im re))
cost-diff	0	(log.f64 #s(literal 10 binary64))
cost-diff	0	(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))
cost-diff	704	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))))
cost-diff	0	(*.f64 re re)
cost-diff	0	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
cost-diff	0	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
cost-diff	128	(+.f64 (.f64 re re) (.f64 im im))
cost-diff	0	(log.f64 #s(literal 10 binary64))
cost-diff	0	(log.f64 im)
cost-diff	0	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
cost-diff	0	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
cost-diff	0	(hypot.f64 im re)
cost-diff	0	(log.f64 (hypot.f64 im re))
cost-diff	0	(neg.f64 (log.f64 (hypot.f64 im re)))
cost-diff	0	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))

Rules

136×	`lower-*.f32`
132×	`lower-*.f64`
116×	`lower-fma.f64`
116×	`lower-fma.f32`
102×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	33	180
0	54	151
1	75	150
2	106	148
3	159	148
4	273	148
5	349	148
6	406	148
7	451	148
8	466	148
9	472	148
0	472	147

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 (hypot.f64 im re)))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
im
re
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(+.f64 (.f64 re re) (.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
im
re
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(literal -1 binary64)
(neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
(pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
im
re

Outputs
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 (hypot.f64 im re)))
(neg.f64 (log.f64 (hypot.f64 re im)))
(log.f64 (hypot.f64 im re))
(log.f64 (hypot.f64 re im))
(hypot.f64 im re)
(hypot.f64 re im)
im
re
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(log.f64 (hypot.f64 re im))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(hypot.f64 re im)
(+.f64 (.f64 re re) (.f64 im im))
(fma.f64 re re (*.f64 im im))
(*.f64 re re)
re
(*.f64 im im)
im
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 re im)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 (hypot.f64 im re))
(log.f64 (hypot.f64 re im))
(hypot.f64 im re)
(hypot.f64 re im)
im
re
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))))
(/.f64 (log.f64 (hypot.f64 re im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(literal -1 binary64)
(neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 re im)))
(pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))
(pow.f64 (log.f64 (hypot.f64 re im)) #s(literal -1 binary64))
(log.f64 (hypot.f64 im re))
(log.f64 (hypot.f64 re im))
(hypot.f64 im re)
(hypot.f64 re im)
im
re

localize130.0ms (1.8%)

Memory

23.3MiB live, 180.0MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.28515625	(pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))
accuracy	0.30859375	(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))))
accuracy	1.0	(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
accuracy	1.0	(log.f64 #s(literal 1/10 binary64))
accuracy	0	(log.f64 (hypot.f64 im re))
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.2890625	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))))
accuracy	0.6166000976844203	(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))
accuracy	0	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
accuracy	0.5947838379159783	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
accuracy	1.0	(log.f64 #s(literal 1/10 binary64))
accuracy	27.96047248509236	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	0	(log.f64 im)
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.25108077410874363	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.5947838379159783	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
accuracy	0	(neg.f64 (log.f64 (hypot.f64 im re)))
accuracy	0	(log.f64 (hypot.f64 im re))
accuracy	0.5947838379159783	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
accuracy	1.0	(log.f64 #s(literal 1/10 binary64))

Samples

110.0ms

256×

valid

Compiler

Compiled 241 to 29 computations (88% saved)

Precisions

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

ival-log: 21.0ms (28.6% of total)

ival-div: 20.0ms (27.3% of total)

ival-hypot: 12.0ms (16.4% of total)

ival-pow: 9.0ms (12.3% of total)

const: 4.0ms (5.5% of total)

ival-mult: 3.0ms (4.1% of total)

ival-neg: 3.0ms (4.1% of total)

ival-add: 1.0ms (1.4% of total)

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

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

exact: 0.0ms (0% of total)

series131.0ms (1.8%)

Memory

8.0MiB live, 158.3MiB allocated

Counts

20 → 384

Calls

Call 1

Inputs
#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())
#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())
#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())
#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())
#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())
#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 binary64)) #<representation binary64>) () ())
#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())
#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())
#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())
#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())
#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())
#s(alt (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 1/10 binary64)) (patch (log.f64 #s(literal 1/10 binary64)) #<representation binary64>) () ())
#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())
#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())

Outputs
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor 0 re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log im)) (taylor 0 re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow re 2) (pow im 2))) (log im)) (taylor 0 re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im)) (taylor 0 re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))) (log im)) (taylor 0 re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (log im)) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log im) 2)))) (/ (log 10) (log im))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (+ (* 1/8 (/ (log 10) (* (pow im 6) (pow (log im) 3)))) (* 1/6 (/ (log 10) (* (pow im 6) (pow (log im) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor 0 re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log im)) (taylor 0 re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log im) 2)))) (/ 1 (log im))) (taylor 0 re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im))) (taylor 0 re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow re 2) (+ (* (pow re 2) (- (* (pow re 2) (+ (* 1/8 (/ 1 (* (pow im 6) (pow (log im) 3)))) (+ (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (* 1/6 (/ 1 (* (pow im 6) (pow (log im) 2))))))) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im))) (taylor 0 re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log im)) (taylor 0 re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log im) 2)))) (/ 1 (log im))) (taylor 0 re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3)))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im))) (taylor 0 re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 1/8 (/ 1 (* (pow im 6) (pow (log im) 3)))) (+ (* 1/6 (/ 1 (* (pow im 6) (pow (log im) 2)))) (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))))))) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im))) (taylor 0 re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 re)) (log 1/10)) (taylor inf re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))) (taylor inf re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))) (taylor inf re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))) (taylor inf re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ 1 re)) (taylor inf re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re)))) (taylor inf re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 re)) (log 1/10)) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))) (taylor inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 re)))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 re)) (log 1/10)) (taylor inf re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))) (taylor inf re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))) (taylor inf re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))) (taylor inf re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ 1 re))) (taylor inf re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))) (taylor inf re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))) (taylor inf re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* -1/8 (/ (pow im 6) (* (pow re 6) (pow (log (/ 1 re)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (* (pow re 6) (log (/ 1 re))))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))))))) (taylor inf re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ 1 re))) (taylor inf re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))) (taylor inf re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))) (taylor inf re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))))) (taylor inf re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 re)) (log 1/10)) (taylor -inf re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))) (taylor -inf re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))) (taylor -inf re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))) (taylor -inf re) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ -1 re)) (taylor -inf re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re)))) (taylor -inf re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 re)) (log 1/10)) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ -1 re)))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 re)) (log 1/10)) (taylor -inf re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))) (taylor -inf re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))) (taylor -inf re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))) (taylor -inf re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ -1 re))) (taylor -inf re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))) (taylor -inf re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))) (taylor -inf re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* -1/8 (/ (pow im 6) (* (pow re 6) (pow (log (/ -1 re)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (* (pow re 6) (log (/ -1 re))))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))))))) (taylor -inf re) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))) (taylor -inf re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))) (taylor -inf re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))))) (taylor -inf re) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log re) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10))))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log re)) (taylor 0 im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow im 2) (pow re 2))) (log re)) (taylor 0 im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (log re)) (taylor 0 im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))) (log re)) (taylor 0 im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (/ (log re) (log 10)) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log re) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10))))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log re) (log 10)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (log re)) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log re) 2)))) (/ (log 10) (log re))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (+ (* 1/8 (/ (log 10) (* (pow re 6) (pow (log re) 3)))) (* 1/6 (/ (log 10) (* (pow re 6) (pow (log re) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log re) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10))))) (taylor 0 im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log re)) (taylor 0 im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log re) 2)))) (/ 1 (log re))) (taylor 0 im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re))) (taylor 0 im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* 1/8 (/ 1 (* (pow re 6) (pow (log re) 3)))) (+ (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (* 1/6 (/ 1 (* (pow re 6) (pow (log re) 2))))))) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re))) (taylor 0 im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log re)) (taylor 0 im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log re) 2)))) (/ 1 (log re))) (taylor 0 im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (- (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3)))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re))) (taylor 0 im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 1/8 (/ 1 (* (pow re 6) (pow (log re) 3)))) (+ (* 1/6 (/ 1 (* (pow re 6) (pow (log re) 2)))) (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))))))) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re))) (taylor 0 im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))) (taylor inf im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))) (taylor inf im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))) (taylor inf im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ 1 im)) (taylor inf im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im)))) (taylor inf im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))) (taylor inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))) (taylor inf im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))) (taylor inf im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))) (taylor inf im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ 1 im))) (taylor inf im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))) (taylor inf im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))) (taylor inf im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* -1/8 (/ (pow re 6) (* (pow im 6) (pow (log (/ 1 im)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (* (pow im 6) (log (/ 1 im))))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))))))) (taylor inf im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ 1 im))) (taylor inf im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))) (taylor inf im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))) (taylor inf im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))))) (taylor inf im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 im)) (log 1/10)) (taylor -inf im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))) (taylor -inf im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))) (taylor -inf im) (#s(alt (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ -1 im)) (taylor -inf im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (neg.f64 (log.f64 (hypot.f64 im re))) (patch (neg.f64 (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (log.f64 (hypot.f64 im re)) (patch (log.f64 (hypot.f64 im re)) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt (hypot.f64 im re) (patch (hypot.f64 im re) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 im)) (log 1/10)) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) (patch (/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ -1 im)))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 im)) (log 1/10)) (taylor -inf im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))) (taylor -inf im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))) (taylor -inf im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ -1 im))) (taylor -inf im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))) (taylor -inf im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* -1/8 (/ (pow re 6) (* (pow im 6) (pow (log (/ -1 im)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (* (pow im 6) (log (/ -1 im))))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))))))) (taylor -inf im) (#s(alt (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))) (taylor -inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ -1 im))) (taylor -inf im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))))) (taylor -inf im) (#s(alt (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #<representation binary64>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
34.0ms	im	@	0	((/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (log 10) (+ (* re re) (* im im)) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (* re re) (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/ (pow (log 1/10) -1) (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1))) (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (log 1/10) -1) (log 1/10) (sqrt (+ (* re re) (* im im))) (pow (log (sqrt (+ (* im im) (* re re)))) -1))
17.0ms	im	@	inf	((/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (log 10) (+ (* re re) (* im im)) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (* re re) (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/ (pow (log 1/10) -1) (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1))) (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (log 1/10) -1) (log 1/10) (sqrt (+ (* re re) (* im im))) (pow (log (sqrt (+ (* im im) (* re re)))) -1))
15.0ms	im	@	-inf	((/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (log 10) (+ (* re re) (* im im)) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (* re re) (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/ (pow (log 1/10) -1) (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1))) (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (log 1/10) -1) (log 1/10) (sqrt (+ (* re re) (* im im))) (pow (log (sqrt (+ (* im im) (* re re)))) -1))
13.0ms	re	@	-inf	((/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (log 10) (+ (* re re) (* im im)) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (* re re) (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/ (pow (log 1/10) -1) (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1))) (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (log 1/10) -1) (log 1/10) (sqrt (+ (* re re) (* im im))) (pow (log (sqrt (+ (* im im) (* re re)))) -1))
6.0ms	re	@	inf	((/ (neg (log (sqrt (+ (* im im) (* re re))))) (log 1/10)) (neg (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (sqrt (+ (* im im) (* re re))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (log 10) (+ (* re re) (* im im)) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (* re re) (/ 1 (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (/ (pow (log 1/10) -1) (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1))) (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (log 1/10) -1) (log 1/10) (sqrt (+ (* re re) (* im im))) (pow (log (sqrt (+ (* im im) (* re re)))) -1))

simplify486.0ms (6.9%)

Memory

-234.5MiB live, 351.4MiB allocated

Algorithm

1×	egg-herbie

Rules

10 076×	`lower-fma.f64`
10 076×	`lower-fma.f32`
7 396×	`lower-*.f64`
7 396×	`lower-*.f32`
4 724×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	911	9804
1	2764	9530
0	8254	9064

Stop Event

1×	iter limit
1×	node limit

Counts

384 → 376

Calls

Call 1

Inputs
(* -1 (/ (log im) (log 1/10)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(* -1 (log im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))
(- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(- (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(* -1 (/ (log im) (log 1/10)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(/ (log 10) (log im))
(+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log im) 2)))) (/ (log 10) (log im)))
(+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im)))
(+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (+ (* 1/8 (/ (log 10) (* (pow im 6) (pow (log im) 3)))) (* 1/6 (/ (log 10) (* (pow im 6) (pow (log im) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im)))
(* -1 (/ (log im) (log 1/10)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(/ -1 (log im))
(- (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log im) 2)))) (/ 1 (log im)))
(- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im)))
(- (* (pow re 2) (+ (* (pow re 2) (- (* (pow re 2) (+ (* 1/8 (/ 1 (* (pow im 6) (pow (log im) 3)))) (+ (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (* 1/6 (/ 1 (* (pow im 6) (pow (log im) 2))))))) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im)))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(/ 1 (log im))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log im) 2)))) (/ 1 (log im)))
(+ (* (pow re 2) (- (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3)))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im)))
(+ (* (pow re 2) (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 1/8 (/ 1 (* (pow im 6) (pow (log im) 3)))) (+ (* 1/6 (/ 1 (* (pow im 6) (pow (log im) 2)))) (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))))))) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im)))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(log (/ 1 re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))
(- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log 10) (log (/ 1 re))))
(+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(/ 1 (log (/ 1 re)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))
(+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))))
(+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* -1/8 (/ (pow im 6) (* (pow re 6) (pow (log (/ 1 re)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (* (pow re 6) (log (/ 1 re))))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(/ -1 (log (/ 1 re)))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(log (/ -1 re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))
(- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log 10) (log (/ -1 re))))
(+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(/ 1 (log (/ -1 re)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))
(+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))))
(+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* -1/8 (/ (pow im 6) (* (pow re 6) (pow (log (/ -1 re)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (* (pow re 6) (log (/ -1 re))))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))))))
(* -1 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(/ -1 (log (/ -1 re)))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))))
(* -1 (/ (log re) (log 1/10)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(* -1 (log re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (log re))
(- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (log re))
(- (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))) (log re))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(log im)
(log im)
(log im)
(log im)
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(* -1 (/ (log re) (log 1/10)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(/ (log 10) (log re))
(+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log re) 2)))) (/ (log 10) (log re)))
(+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re)))
(+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (+ (* 1/8 (/ (log 10) (* (pow re 6) (pow (log re) 3)))) (* 1/6 (/ (log 10) (* (pow re 6) (pow (log re) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re)))
(* -1 (/ (log re) (log 1/10)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(/ -1 (log re))
(- (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log re) 2)))) (/ 1 (log re)))
(- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re)))
(- (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* 1/8 (/ 1 (* (pow re 6) (pow (log re) 3)))) (+ (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (* 1/6 (/ 1 (* (pow re 6) (pow (log re) 2))))))) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re)))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(/ 1 (log re))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log re) 2)))) (/ 1 (log re)))
(+ (* (pow im 2) (- (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3)))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re)))
(+ (* (pow im 2) (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 1/8 (/ 1 (* (pow re 6) (pow (log re) 3)))) (+ (* 1/6 (/ 1 (* (pow re 6) (pow (log re) 2)))) (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))))))) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re)))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(log (/ 1 im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))
(- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log 10) (log (/ 1 im))))
(+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(/ 1 (log (/ 1 im)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))
(+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))))
(+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* -1/8 (/ (pow re 6) (* (pow im 6) (pow (log (/ 1 im)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (* (pow im 6) (log (/ 1 im))))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(/ -1 (log (/ 1 im)))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(log (/ -1 im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))
(- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log 10) (log (/ -1 im))))
(+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(/ 1 (log (/ -1 im)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))
(+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))))
(+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* -1/8 (/ (pow re 6) (* (pow im 6) (pow (log (/ -1 im)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (* (pow im 6) (log (/ -1 im))))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))))
(* -1 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(/ -1 (log (/ -1 im)))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))

Outputs
(* -1 (/ (log im) (log 1/10)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(* -1 (log im))
(neg.f64 (log.f64 im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))
(-.f64 (.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 (.f64 re re) im)) (log.f64 im))
(- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (/.f64 #s(literal -1/2 binary64) (.f64 im im))) (.f64 re re)) (log.f64 im))
(- (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(-.f64 (.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 im im))) (*.f64 re re)) (log.f64 im))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re) (log.f64 im))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) #s(literal 1/16 binary64) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im)
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re) (log.f64 im))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/6 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re) (log.f64 im))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log im) 2)))) (/ (log 10) (log im)))
(fma.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) im) im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im)))
(fma.f64 (fma.f64 (.f64 #s(literal 1/4 binary64) (+.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (.f64 re re) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) im) im)) #s(literal -1/2 binary64))) (*.f64 re re) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (+ (* 1/8 (/ (log 10) (* (pow im 6) (pow (log im) 3)))) (* 1/6 (/ (log 10) (* (pow im 6) (pow (log im) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im)))
(fma.f64 (fma.f64 (fma.f64 (.f64 (neg.f64 re) re) (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 #s(literal 1/8 binary64) (+.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (.f64 (.f64 (log.f64 im) im) im)))) (.f64 #s(literal 1/4 binary64) (+.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64))))))) (.f64 re re) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) im) im)) #s(literal -1/2 binary64))) (.f64 re re) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/ -1 (log im))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(- (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log im) 2)))) (/ 1 (log im)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im)))
(fma.f64 (fma.f64 (.f64 (neg.f64 re) re) (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) im) im))) (.f64 re re) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(- (* (pow re 2) (+ (* (pow re 2) (- (* (pow re 2) (+ (* 1/8 (/ 1 (* (pow im 6) (pow (log im) 3)))) (+ (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (* 1/6 (/ 1 (* (pow im 6) (pow (log im) 2))))))) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im)))
(fma.f64 (fma.f64 (fma.f64 (+.f64 (fma.f64 (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 (.f64 (log.f64 im) im) im)) #s(literal 1/2 binary64) (/.f64 #s(literal 1/6 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 im #s(literal 6 binary64))))) (/.f64 #s(literal 1/8 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64))))) (.f64 re re) (neg.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))))))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) im) im))) (*.f64 re re) (/.f64 #s(literal -1 binary64) (log.f64 im)))
im
(+ im (* 1/2 (/ (pow re 2) im)))
(fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im)
(+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im)
(+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im)))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 5 binary64))) #s(literal 1/16 binary64) (/.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 3 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im)
(/ 1 (log im))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log im) 2)))) (/ 1 (log im)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(+ (* (pow re 2) (- (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3)))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im)))
(fma.f64 (fma.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) im) im))) (.f64 re re) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(+ (* (pow re 2) (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 1/8 (/ 1 (* (pow im 6) (pow (log im) 3)))) (+ (* 1/6 (/ 1 (* (pow im 6) (pow (log im) 2)))) (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))))))) (+ (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 2)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log im) 2)))))) (/ 1 (log im)))
(fma.f64 (fma.f64 (fma.f64 (.f64 (neg.f64 re) re) (+.f64 (fma.f64 (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 (.f64 (log.f64 im) im) im)) #s(literal 1/2 binary64) (/.f64 #s(literal 1/6 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 im #s(literal 6 binary64))))) (/.f64 #s(literal 1/8 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64))))) (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) im) im))) (*.f64 re re) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ 1 re))
(neg.f64 (log.f64 re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) re) (/.f64 (*.f64 im im) re) (neg.f64 (log.f64 re)))
(- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64) (neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))))
(- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/720 binary64) (neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 re)))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 (/.f64 im re) (/.f64 im re)) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) re re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) re re)
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 re)))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 re)))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log 10) (log (/ 1 re))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))
(+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 binary64) (fma.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (*.f64 re re))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(-.f64 (-.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (fma.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))))) (.f64 im im)) (log.f64 re)) (fma.f64 (.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))) (pow.f64 re #s(literal 4 binary64)))) (.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re)))))))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
(/ 1 (log (/ 1 re)))
(/.f64 #s(literal -1 binary64) (log.f64 re))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 re)))
(+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 re)))))
(+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* -1/8 (/ (pow im 6) (* (pow re 6) (pow (log (/ 1 re)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (* (pow re 6) (log (/ 1 re))))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal -1/8 binary64) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (fma.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) (neg.f64 (log.f64 re))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 (/.f64 im re) (/.f64 im re)) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) (/.f64 #s(literal -1 binary64) (log.f64 re)))))))
re
(* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (.f64 re #s(literal 1/2 binary64)) (.f64 (/.f64 im re) (/.f64 im re)) re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) re re)
(* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) re re)
(/ -1 (log (/ 1 re)))
(/.f64 #s(literal 1 binary64) (log.f64 re))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 re)))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) (neg.f64 (pow.f64 re #s(literal 4 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (*.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 re))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) #s(literal 1/720 binary64) (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) (.f64 im im)) (log.f64 re))))) (neg.f64 (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (*.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 re))))))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ -1 re))
(log.f64 (/.f64 #s(literal -1 binary64) re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re)))
(- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/720 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(.f64 (neg.f64 re) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64)))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(.f64 (neg.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(neg.f64 (fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) re re))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log 10) (log (/ -1 re))))
(/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) re) (/.f64 (.f64 im im) re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) re) (/.f64 (*.f64 im im) re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(-.f64 (-.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (fma.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 (.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (.f64 (.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))))) (neg.f64 (pow.f64 re #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(/ 1 (log (/ -1 re)))
(/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))
(fma.f64 (/.f64 (*.f64 (/.f64 im re) (/.f64 im re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))))
(fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 im re) (/.f64 im re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))))
(+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* -1/8 (/ (pow im 6) (* (pow re 6) (pow (log (/ -1 re)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (* (pow re 6) (log (/ -1 re))))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (fma.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (/.f64 (.f64 (/.f64 im re) (/.f64 im re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))))))
(* -1 re)
(neg.f64 re)
(* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))
(.f64 (neg.f64 re) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64)))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
(.f64 (neg.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) #s(literal 1 binary64))))
(* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
(neg.f64 (fma.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/16 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) re re))
(/ -1 (log (/ -1 re)))
(/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))
(fma.f64 (/.f64 (*.f64 (/.f64 im re) (/.f64 im re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (neg.f64 (pow.f64 re #s(literal 4 binary64)))) (fma.f64 (/.f64 (.f64 (/.f64 im re) (/.f64 im re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))))
(-.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))))) (neg.f64 (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (fma.f64 (/.f64 (.f64 (/.f64 im re) (/.f64 im re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))))))
(* -1 (/ (log re) (log 1/10)))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(* -1 (log re))
(neg.f64 (log.f64 re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (log re))
(fma.f64 (/.f64 #s(literal -1/2 binary64) re) (/.f64 (*.f64 im im) re) (neg.f64 (log.f64 re)))
(- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (log re))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64) (/.f64 #s(literal -1/2 binary64) (.f64 re re))) (*.f64 im im) (neg.f64 (log.f64 re)))
(- (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))) (log re))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 re re))) (.f64 im im) (neg.f64 (log.f64 re)))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im) (log.f64 re))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) re) re))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) re) re))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im) (log.f64 re))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(* -1 (/ (log re) (log 1/10)))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im) (log.f64 re))
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) re) re))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) re) re))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(/ (log 10) (log re))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))
(+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log re) 2)))) (/ (log 10) (log re)))
(fma.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re)))
(fma.f64 (fma.f64 (.f64 #s(literal 1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (.f64 im im) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) #s(literal -1/2 binary64))) (.f64 im im) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (+ (* 1/8 (/ (log 10) (* (pow re 6) (pow (log re) 3)))) (* 1/6 (/ (log 10) (* (pow re 6) (pow (log re) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re)))
(fma.f64 (fma.f64 (fma.f64 (.f64 (neg.f64 im) im) (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 re) #s(literal 3 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 #s(literal 1/8 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (.f64 (.f64 (log.f64 re) re) re)))) (.f64 #s(literal 1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64))))))) (.f64 im im) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) #s(literal -1/2 binary64))) (.f64 im im) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(* -1 (/ (log re) (log 1/10)))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(/ -1 (log re))
(/.f64 #s(literal -1 binary64) (log.f64 re))
(- (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log re) 2)))) (/ 1 (log re)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 #s(literal -1 binary64) (log.f64 re)))
(- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re)))
(fma.f64 (fma.f64 (.f64 (neg.f64 im) im) (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))) (/.f64 #s(literal 1/2 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re)))) (.f64 im im) (/.f64 #s(literal -1 binary64) (log.f64 re)))
(- (* (pow im 2) (+ (* (pow im 2) (- (* (pow im 2) (+ (* 1/8 (/ 1 (* (pow re 6) (pow (log re) 3)))) (+ (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (* 1/6 (/ 1 (* (pow re 6) (pow (log re) 2))))))) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re)))
(fma.f64 (fma.f64 (fma.f64 (+.f64 (fma.f64 (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))) (.f64 (.f64 (log.f64 re) re) re)) #s(literal 1/2 binary64) (/.f64 #s(literal 1/6 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 6 binary64))))) (/.f64 #s(literal 1/8 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64))))) (.f64 im im) (neg.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re)))) (*.f64 im im) (/.f64 #s(literal -1 binary64) (log.f64 re)))
re
(+ re (* 1/2 (/ (pow im 2) re)))
(fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re)
(+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 3 binary64))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re)
(+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re)))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 5 binary64))) #s(literal 1/16 binary64) (/.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 3 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (*.f64 im im) re)
(/ 1 (log re))
(/.f64 #s(literal 1 binary64) (log.f64 re))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log re) 2)))) (/ 1 (log re)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 #s(literal 1 binary64) (log.f64 re)))
(+ (* (pow im 2) (- (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3)))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re)))
(fma.f64 (fma.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re)))) (.f64 im im) (/.f64 #s(literal 1 binary64) (log.f64 re)))
(+ (* (pow im 2) (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 1/8 (/ 1 (* (pow re 6) (pow (log re) 3)))) (+ (* 1/6 (/ 1 (* (pow re 6) (pow (log re) 2)))) (* 1/2 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))))))) (+ (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 2)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log re) 2)))))) (/ 1 (log re)))
(fma.f64 (fma.f64 (fma.f64 (.f64 (neg.f64 im) im) (+.f64 (fma.f64 (/.f64 (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))) (.f64 (.f64 (log.f64 re) re) re)) #s(literal 1/2 binary64) (/.f64 #s(literal 1/6 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 6 binary64))))) (/.f64 #s(literal 1/8 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64))))) (+.f64 (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re)))) (*.f64 im im) (/.f64 #s(literal 1 binary64) (log.f64 re)))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))
(-.f64 (.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 (.f64 re re) im)) (log.f64 im))
(- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))))
(- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/720 binary64) (neg.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (log.f64 im)))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64)))) (log.f64 im)))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64)) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64))) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/16 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) im im)
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64)))) (log.f64 im)))
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64)))) (log.f64 im)))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) im) im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(+.f64 (/.f64 (fma.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (neg.f64 (pow.f64 im #s(literal 4 binary64)))) (fma.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (*.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) im) im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(-.f64 (-.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (fma.f64 (.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (fma.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (.f64 re re)) (log.f64 im)) (.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) im) im)) (.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))))
(/ 1 (log (/ 1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 im))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 #s(literal -1 binary64) (log.f64 im)))
(+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 #s(literal -1 binary64) (log.f64 im)))))
(+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* -1/8 (/ (pow re 6) (* (pow im 6) (pow (log (/ 1 im)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (* (pow im 6) (log (/ 1 im))))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (fma.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (neg.f64 (log.f64 im))) (.f64 (/.f64 re (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 re (*.f64 im im)))) (/.f64 #s(literal -1 binary64) (log.f64 im)))))))
im
(* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))
(.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64)) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64))) im)
(* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/16 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) im im)
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (neg.f64 (pow.f64 im #s(literal 4 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))
(-.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal 1/720 binary64) (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (.f64 re re)) (log.f64 im)) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (neg.f64 (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (/.f64 #s(literal -1 binary64) (log.f64 im))))))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ -1 im))
(log.f64 (/.f64 #s(literal -1 binary64) im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im)))
(- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/720 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(.f64 (neg.f64 im) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(.f64 (neg.f64 im) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(neg.f64 (fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/16 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) im im))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log 10) (log (/ -1 im))))
(/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 im #s(literal 4 binary64))) #s(literal -1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (*.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(-.f64 (-.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 (.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (.f64 (.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))))) (neg.f64 (pow.f64 im #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (fma.f64 (/.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64)))))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(/ 1 (log (/ -1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))
(fma.f64 (/.f64 (*.f64 (/.f64 re im) (/.f64 re im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))))
(fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 re im) (/.f64 re im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
(+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* -1/8 (/ (pow re 6) (* (pow im 6) (pow (log (/ -1 im)) 3)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (* (pow im 6) (log (/ -1 im))))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal -1/8 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 #s(literal 1/2 binary64) (fma.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 (/.f64 #s(literal -1 binary64) im))) (/.f64 (.f64 (/.f64 re im) (/.f64 re im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))))))
(* -1 im)
(neg.f64 im)
(* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))
(.f64 (neg.f64 im) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64)))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
(.f64 (neg.f64 im) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) #s(literal 1 binary64))))
(* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
(neg.f64 (fma.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/16 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) im im))
(/ -1 (log (/ -1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))
(fma.f64 (/.f64 (*.f64 (/.f64 re im) (/.f64 re im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (neg.f64 (pow.f64 im #s(literal 4 binary64)))) (fma.f64 (/.f64 (.f64 (/.f64 re im) (/.f64 re im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))
(-.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))))) (neg.f64 (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (fma.f64 (/.f64 (.f64 (/.f64 re im) (/.f64 re im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))

rewrite243.0ms (3.4%)

Memory

21.9MiB live, 305.5MiB allocated

Rules

3 556×	`lower-fma.f64`
3 556×	`lower-fma.f32`
3 282×	`lower-*.f32`
3 278×	`lower-*.f64`
2 254×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	33	138
0	54	104
1	155	103
2	712	103
3	5847	103
0	8039	102

Stop Event

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

Counts

20 → 1 262

Calls

Call 1

Inputs
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (log.f64 (hypot.f64 im re)))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
(log.f64 #s(literal 10 binary64))
(+.f64 (.f64 re re) (.f64 im im))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(*.f64 re re)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))))
(neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(log.f64 #s(literal 1/10 binary64))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval301.0ms (4.2%)

Memory: -3.8MiB live, 571.0MiB allocated
Compiler: Compiled 44 136 to 5 089 computations (88.5% saved)

prune73.0ms (1%)

Memory

-11.6MiB live, 155.0MiB allocated

Pruning

13 alts after pruning (12 fresh and 1 done)

	Pruned	Kept	Total
New	2 124	10	2 134
Fresh	3	2	5
Picked	4	1	5
Done	0	0	0
Total	2 131	13	2 144

Accuracy

100.0%

Counts

2 144 → 13

Alt Table

Click to see full alt table

Status	Accuracy	Program
	71.9%	(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
	71.3%	(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (exp.f64 (neg.f64 (log.f64 (log.f64 (hypot.f64 re im)))))))
	98.6%	(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) #s(approx (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (/.f64 #s(literal -1 binary64) (log.f64 im))))
▶	54.1%	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
	54.1%	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
▶	98.6%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓	98.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
	54.1%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64))))
▶	98.6%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	54.1%	(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (pow.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1 binary64))))
▶	54.1%	(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
	98.6%	(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
▶	98.9%	(.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))

Compiler

Compiled 288 to 273 computations (5.2% saved)

simplify132.0ms (1.9%)

Memory

35.3MiB live, 188.3MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	(log.f64 #s(literal 1/10 binary64))
cost-diff	0	(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))
cost-diff	704	(.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
cost-diff	704	(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
cost-diff	0	(fma.f64 im im (*.f64 re re))
cost-diff	0	(log.f64 (fma.f64 im im (*.f64 re re)))
cost-diff	0	(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
cost-diff	0	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
cost-diff	0	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
cost-diff	0	(log.f64 #s(literal 10 binary64))
cost-diff	0	(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
cost-diff	704	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
cost-diff	0	(log.f64 im)
cost-diff	0	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
cost-diff	0	(neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
cost-diff	0	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
cost-diff	0	(log.f64 im)
cost-diff	0	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
cost-diff	0	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
cost-diff	19648	(.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))

Rules

12 868×	`lower-fma.f32`
12 864×	`lower-fma.f64`
3 628×	`lower-*.f32`
3 618×	`lower-*.f64`
1 890×	`lower-neg.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	39	273
0	62	280
1	93	280
2	168	273
3	403	258
4	1229	258
5	2514	258
6	3827	258
7	7999	258
0	8006	222

Stop Event

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

Calls

Call 1

Inputs
(.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(literal 3 binary64)
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
(log.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
im
(*.f64 re re)
re
#s(literal 1/2 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
#s(literal 1 binary64)
(.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(literal 1/2 binary64)
(/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
#s(literal -1 binary64)
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
re
(*.f64 im im)
im

Outputs
(.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(literal 3 binary64)
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
#s(literal 2 binary64)
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
#s(literal 1 binary64)
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 im im (.f64 re re))))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(log.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
im
(*.f64 re re)
re
#s(literal 1/2 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 im im (.f64 re re))))
#s(literal 1 binary64)
(.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
(/.f64 (.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 im im (.f64 re re))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(literal 1/2 binary64)
(/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
(/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 im im (*.f64 re re))))
#s(literal -1 binary64)
(log.f64 (fma.f64 re re (*.f64 im im)))
(log.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 re re (*.f64 im im))
(fma.f64 im im (*.f64 re re))
re
(*.f64 im im)
im

localize148.0ms (2.1%)

Memory

-36.4MiB live, 256.2MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.2890625	(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
accuracy	0.6308975586106521	(.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
accuracy	1.0	(log.f64 #s(literal 1/10 binary64))
accuracy	29.05589690548192	(log.f64 (fma.f64 re re (*.f64 im im)))
accuracy	0	(*.f64 re re)
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.5947838379159783	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
accuracy	29.05589690548192	(log.f64 (fma.f64 im im (*.f64 re re)))
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.25108077410874363	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.2890625	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
accuracy	0.6166000976844203	(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
accuracy	0	(log.f64 im)
accuracy	0.25108077410874363	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.5947838379159783	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
accuracy	1.0	(log.f64 #s(literal 1/10 binary64))
accuracy	0.4801750488422102	(.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
accuracy	1.0	(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
accuracy	1.0	(log.f64 #s(literal 1/10 binary64))
accuracy	1.58496250072115	(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))

Samples

118.0ms

256×

valid

Compiler

Compiled 266 to 37 computations (86.1% saved)

Precisions

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

ival-hypot: 23.0ms (26.5% of total)

ival-log: 17.0ms (19.6% of total)

ival-div: 16.0ms (18.4% of total)

ival-pow: 10.0ms (11.5% of total)

ival-mult: 7.0ms (8.1% of total)

const: 6.0ms (6.9% of total)

ival-add: 2.0ms (2.3% of total)

ival-neg: 2.0ms (2.3% of total)

ival-pow2: 2.0ms (2.3% of total)

exact: 1.0ms (1.2% of total)

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

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

series70.0ms (1%)

Memory

15.3MiB live, 137.3MiB allocated

Counts

21 → 360

Calls

Call 1

Inputs
#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())
#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())
#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())
#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())
#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())
#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 binary64)) #<representation binary64>) () ())
#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())
#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())
#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 1/10 binary64)) (patch (log.f64 #s(literal 1/10 binary64)) #<representation binary64>) () ())
#s(alt (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (patch (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) #<representation binary64>) () ())
#s(alt (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())
#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())

Outputs
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (pow (log 1/10) 3))) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (pow (log 1/10) 3))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3))))) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (pow (log 1/10) 3))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (pow (log 1/10) 3)))) (* 1/2 (/ 1 (* (pow im 2) (pow (log 1/10) 3))))))) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (pow (log 1/10) 3))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (pow (log 1/10) 3)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log 1/10) 3)))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log 1/10) 3))))))) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor 0 re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log im)) (taylor 0 re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow re 2) (pow im 2))) (log im)) (taylor 0 re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im)) (taylor 0 re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))) (log im)) (taylor 0 re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (log im)) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log im) 2)))) (/ (log 10) (log im))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (+ (* 1/8 (/ (log 10) (* (pow im 6) (pow (log im) 3)))) (* 1/6 (/ (log 10) (* (pow im 6) (pow (log im) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow im 2)) (log 10))) (taylor 0 re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor 0 re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (log (pow im 2))) (taylor 0 re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (log (pow im 2)) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* -1/2 (/ (log (pow im 2)) (log 1/10))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (* -2 (/ (log 1/10) (log (pow im 2)))) (taylor 0 re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log 1/10) (log (pow im 2)))) (* 2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (pow im 2)) 2))))) (taylor 0 re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* 2 (* (pow re 2) (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* 2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2))))))) (taylor 0 re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* 2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* 2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* 2 (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))))))))) (taylor 0 re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (log (pow im 2)) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 re)) (log 1/10)) (taylor inf re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))) (taylor inf re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))) (taylor inf re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))) (taylor inf re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 re)) (pow (log 1/10) 3)) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (/ (log (/ 1 re)) (pow (log 1/10) 3))) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ 1 re)) (pow (log 1/10) 3)))) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ 1 re)) (pow (log 1/10) 3))))) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 re)) (log 1/10)) (taylor inf re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))) (taylor inf re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))) (taylor inf re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))) (taylor inf re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ 1 re)) (taylor inf re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re)))) (taylor inf re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 re)))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 re)) (log 1/10)) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (log (/ 1 re))) (taylor inf re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ (log 1/10) (log (/ 1 re)))) (taylor inf re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (/ (log 1/10) (log (/ 1 re))))) (taylor inf re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (/ (log 1/10) (log (/ 1 re)))))) (taylor inf re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 re)) (log 1/10)) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))) (taylor -inf re) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 re)) (pow (log 1/10) 3)) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (/ (log (/ -1 re)) (pow (log 1/10) 3))) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ -1 re)) (pow (log 1/10) 3)))) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ -1 re)) (pow (log 1/10) 3))))) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 re)) (log 1/10)) (taylor -inf re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))) (taylor -inf re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))) (taylor -inf re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))) (taylor -inf re) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ -1 re)) (taylor -inf re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re)))) (taylor -inf re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ -1 re)))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 re)) (log 1/10)) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (log (/ -1 re))) (taylor -inf re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ (log 1/10) (log (/ -1 re)))) (taylor -inf re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (/ (log 1/10) (log (/ -1 re))))) (taylor -inf re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (/ (log 1/10) (log (/ -1 re)))))) (taylor -inf re) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log re) (log 1/10))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10))))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log re) (pow (log 1/10) 3))) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (pow (log 1/10) 3))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3))))) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (pow (log 1/10) 3))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (pow (log 1/10) 3)))) (* 1/2 (/ 1 (* (pow re 2) (pow (log 1/10) 3))))))) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (pow (log 1/10) 3))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (pow (log 1/10) 3)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log 1/10) 3)))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log 1/10) 3))))))) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log re) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10))))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log re)) (taylor 0 im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow im 2) (pow re 2))) (log re)) (taylor 0 im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (log re)) (taylor 0 im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))) (log re)) (taylor 0 im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (log re) (log 10)) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log 10) (log re)) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log re) 2)))) (/ (log 10) (log re))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (+ (* 1/8 (/ (log 10) (* (pow re 6) (pow (log re) 3)))) (* 1/6 (/ (log 10) (* (pow re 6) (pow (log re) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow re 2)) (log 10))) (taylor 0 im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor 0 im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (log (pow re 2))) (taylor 0 im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (log (pow re 2)) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* -1/2 (/ (log (pow re 2)) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10))))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (* -2 (/ (log 1/10) (log (pow re 2)))) (taylor 0 im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log 1/10) (log (pow re 2)))) (* 2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (pow re 2)) 2))))) (taylor 0 im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* 2 (* (pow im 2) (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* 2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2))))))) (taylor 0 im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* 2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* 2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* 2 (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))))))))) (taylor 0 im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (log (pow re 2)) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))) (taylor inf im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))) (taylor inf im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))) (taylor inf im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (pow (log 1/10) 3)) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (/ (log (/ 1 im)) (pow (log 1/10) 3))) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ 1 im)) (pow (log 1/10) 3)))) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ 1 im)) (pow (log 1/10) 3))))) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))) (taylor inf im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))) (taylor inf im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))) (taylor inf im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ 1 im)) (taylor inf im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im)))) (taylor inf im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (log (/ 1 im))) (taylor inf im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ (log 1/10) (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (/ (log 1/10) (log (/ 1 im))))) (taylor inf im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (/ (log 1/10) (log (/ 1 im)))))) (taylor inf im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 im)) (log 1/10)) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))) (taylor -inf im) (#s(alt (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (patch (.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 im)) (pow (log 1/10) 3)) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (/ (log (/ -1 im)) (pow (log 1/10) 3))) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ -1 im)) (pow (log 1/10) 3)))) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ -1 im)) (pow (log 1/10) 3))))) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (log.f64 im) (patch (log.f64 im) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 im)) (log 1/10)) (taylor -inf im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))) (taylor -inf im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))) (taylor -inf im) (#s(alt (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ -1 im)) (taylor -inf im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ -1 im)))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (patch (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 im im (.f64 re re)) (patch (fma.f64 im im (.f64 re re)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 im)) (log 1/10)) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (log (/ -1 im))) (taylor -inf im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ (log 1/10) (log (/ -1 im)))) (taylor -inf im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (/ (log 1/10) (log (/ -1 im))))) (taylor -inf im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (/ (log 1/10) (log (/ -1 im)))))) (taylor -inf im) (#s(alt (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (patch (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
14.0ms	im	@	inf	((* (/ (log (sqrt (+ (* re re) (* im im)))) (neg (pow (log 1/10) 3))) (pow (log 1/10) 2)) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (pow (log 1/10) 3))) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) (/ (* (log (+ (* im im) (* re re))) 1/2) (log 10)) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ 1 (* (/ (log 1/10) 1/2) (/ -1 (log (+ (* re re) (* im im)))))) (* (/ (log 1/10) 1/2) (/ -1 (log (+ (* re re) (* im im))))) (/ (log 1/10) 1/2) (log 1/10) (pow (log 1/10) 3) (pow (log 1/10) 2) (* re re) (log (+ (* re re) (* im im))))
14.0ms	im	@	0	((* (/ (log (sqrt (+ (* re re) (* im im)))) (neg (pow (log 1/10) 3))) (pow (log 1/10) 2)) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (pow (log 1/10) 3))) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) (/ (* (log (+ (* im im) (* re re))) 1/2) (log 10)) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ 1 (* (/ (log 1/10) 1/2) (/ -1 (log (+ (* re re) (* im im)))))) (* (/ (log 1/10) 1/2) (/ -1 (log (+ (* re re) (* im im))))) (/ (log 1/10) 1/2) (log 1/10) (pow (log 1/10) 3) (pow (log 1/10) 2) (* re re) (log (+ (* re re) (* im im))))
9.0ms	im	@	-inf	((* (/ (log (sqrt (+ (* re re) (* im im)))) (neg (pow (log 1/10) 3))) (pow (log 1/10) 2)) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (pow (log 1/10) 3))) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) (/ (* (log (+ (* im im) (* re re))) 1/2) (log 10)) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ 1 (* (/ (log 1/10) 1/2) (/ -1 (log (+ (* re re) (* im im)))))) (* (/ (log 1/10) 1/2) (/ -1 (log (+ (* re re) (* im im))))) (/ (log 1/10) 1/2) (log 1/10) (pow (log 1/10) 3) (pow (log 1/10) 2) (* re re) (log (+ (* re re) (* im im))))
7.0ms	re	@	0	((* (/ (log (sqrt (+ (* re re) (* im im)))) (neg (pow (log 1/10) 3))) (pow (log 1/10) 2)) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (pow (log 1/10) 3))) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) (/ (* (log (+ (* im im) (* re re))) 1/2) (log 10)) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ 1 (* (/ (log 1/10) 1/2) (/ -1 (log (+ (* re re) (* im im)))))) (* (/ (log 1/10) 1/2) (/ -1 (log (+ (* re re) (* im im))))) (/ (log 1/10) 1/2) (log 1/10) (pow (log 1/10) 3) (pow (log 1/10) 2) (* re re) (log (+ (* re re) (* im im))))
5.0ms	re	@	inf	((* (/ (log (sqrt (+ (* re re) (* im im)))) (neg (pow (log 1/10) 3))) (pow (log 1/10) 2)) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (pow (log 1/10) 3))) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (log 10) (/ (* (log (+ (* im im) (* re re))) 1/2) (log 10)) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ 1 (* (/ (log 1/10) 1/2) (/ -1 (log (+ (* re re) (* im im)))))) (* (/ (log 1/10) 1/2) (/ -1 (log (+ (* re re) (* im im))))) (/ (log 1/10) 1/2) (log 1/10) (pow (log 1/10) 3) (pow (log 1/10) 2) (* re re) (log (+ (* re re) (* im im))))

simplify277.0ms (3.9%)

Memory

-1.7MiB live, 227.6MiB allocated

Algorithm

1×	egg-herbie

Rules

10 680×	`lower-fma.f64`
10 680×	`lower-fma.f32`
7 806×	`lower-*.f64`
7 806×	`lower-*.f32`
4 760×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	950	9334
1	2855	9094
0	8291	8674

Stop Event

1×	iter limit
1×	node limit

Counts

360 → 360

Calls

Call 1

Inputs
(* -1 (/ (log im) (log 1/10)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(* -1 (/ (log im) (pow (log 1/10) 3)))
(+ (* -1 (/ (log im) (pow (log 1/10) 3))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))))
(+ (* -1 (/ (log im) (pow (log 1/10) 3))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (pow (log 1/10) 3)))) (* 1/2 (/ 1 (* (pow im 2) (pow (log 1/10) 3)))))))
(+ (* -1 (/ (log im) (pow (log 1/10) 3))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (pow (log 1/10) 3)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log 1/10) 3)))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log 1/10) 3)))))))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1 (/ (log im) (log 1/10)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(* -1 (log im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))
(- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(- (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(/ (log 10) (log im))
(+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log im) 2)))) (/ (log 10) (log im)))
(+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im)))
(+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (+ (* 1/8 (/ (log 10) (* (pow im 6) (pow (log im) 3)))) (* 1/6 (/ (log 10) (* (pow im 6) (pow (log im) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im)))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(* 1/2 (log (pow im 2)))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(* -1/2 (/ (log (pow im 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(* -2 (/ (log 1/10) (log (pow im 2))))
(+ (* -2 (/ (log 1/10) (log (pow im 2)))) (* 2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (pow im 2)) 2)))))
(+ (* -2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* 2 (* (pow re 2) (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* 2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2)))))))
(+ (* -2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* 2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* 2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* 2 (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2)))))))))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(/ (log (/ 1 re)) (pow (log 1/10) 3))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (/ (log (/ 1 re)) (pow (log 1/10) 3)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ 1 re)) (pow (log 1/10) 3))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ 1 re)) (pow (log 1/10) 3)))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(log (/ 1 re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))
(- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log 10) (log (/ 1 re))))
(+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(/ (log 1/10) (log (/ 1 re)))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ (log 1/10) (log (/ 1 re))))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (/ (log 1/10) (log (/ 1 re)))))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (/ (log 1/10) (log (/ 1 re))))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(/ (log (/ -1 re)) (pow (log 1/10) 3))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (/ (log (/ -1 re)) (pow (log 1/10) 3)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ -1 re)) (pow (log 1/10) 3))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ -1 re)) (pow (log 1/10) 3)))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(log (/ -1 re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))
(- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (/ (log 10) (log (/ -1 re))))
(+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(/ (log 1/10) (log (/ -1 re)))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ (log 1/10) (log (/ -1 re))))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (/ (log 1/10) (log (/ -1 re)))))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (/ (log 1/10) (log (/ -1 re))))))
(pow re 2)
(pow re 2)
(pow re 2)
(pow re 2)
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(* -1 (/ (log re) (log 1/10)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(* -1 (/ (log re) (pow (log 1/10) 3)))
(+ (* -1 (/ (log re) (pow (log 1/10) 3))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))))
(+ (* -1 (/ (log re) (pow (log 1/10) 3))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (pow (log 1/10) 3)))) (* 1/2 (/ 1 (* (pow re 2) (pow (log 1/10) 3)))))))
(+ (* -1 (/ (log re) (pow (log 1/10) 3))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (pow (log 1/10) 3)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log 1/10) 3)))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log 1/10) 3)))))))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(log im)
(log im)
(log im)
(log im)
(* -1 (/ (log re) (log 1/10)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(* -1 (log re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (log re))
(- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (log re))
(- (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))) (log re))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(/ (log 10) (log re))
(+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log re) 2)))) (/ (log 10) (log re)))
(+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re)))
(+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (+ (* 1/8 (/ (log 10) (* (pow re 6) (pow (log re) 3)))) (* 1/6 (/ (log 10) (* (pow re 6) (pow (log re) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re)))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(* 1/2 (log (pow re 2)))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(* -2 (/ (log 1/10) (log (pow re 2))))
(+ (* -2 (/ (log 1/10) (log (pow re 2)))) (* 2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (pow re 2)) 2)))))
(+ (* -2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* 2 (* (pow im 2) (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* 2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2)))))))
(+ (* -2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* 2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* 2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* 2 (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2)))))))))))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(/ (log (/ 1 im)) (pow (log 1/10) 3))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (/ (log (/ 1 im)) (pow (log 1/10) 3)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ 1 im)) (pow (log 1/10) 3))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ 1 im)) (pow (log 1/10) 3)))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(log (/ 1 im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))
(- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log 10) (log (/ 1 im))))
(+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(/ (log 1/10) (log (/ 1 im)))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ (log 1/10) (log (/ 1 im))))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (/ (log 1/10) (log (/ 1 im)))))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (/ (log 1/10) (log (/ 1 im))))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(/ (log (/ -1 im)) (pow (log 1/10) 3))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (/ (log (/ -1 im)) (pow (log 1/10) 3)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ -1 im)) (pow (log 1/10) 3))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ -1 im)) (pow (log 1/10) 3)))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(log (/ -1 im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))
(- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (/ (log 10) (log (/ -1 im))))
(+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(/ (log 1/10) (log (/ -1 im)))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ (log 1/10) (log (/ -1 im))))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (/ (log 1/10) (log (/ -1 im)))))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (/ (log 1/10) (log (/ -1 im))))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))

Outputs
(* -1 (/ (log im) (log 1/10)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log im) (pow (log 1/10) 3)))
(/.f64 (neg.f64 (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(+ (* -1 (/ (log im) (pow (log 1/10) 3))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(+ (* -1 (/ (log im) (pow (log 1/10) 3))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (pow (log 1/10) 3)))) (* 1/2 (/ 1 (* (pow im 2) (pow (log 1/10) 3)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(+ (* -1 (/ (log im) (pow (log 1/10) 3))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (pow (log 1/10) 3)))) (* 1/4 (/ 1 (* (pow im 4) (pow (log 1/10) 3)))))) (* 1/2 (/ 1 (* (pow im 2) (pow (log 1/10) 3)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re) (log.f64 im))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(* -1 (log im))
(neg.f64 (log.f64 im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (log im))
(-.f64 (.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 (.f64 re re) im)) (log.f64 im))
(- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (/.f64 #s(literal -1/2 binary64) (.f64 im im))) (.f64 re re)) (log.f64 im))
(- (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))) (log im))
(-.f64 (.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 im im))) (*.f64 re re)) (log.f64 im))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/ (log 10) (log im))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(+ (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log im) 2)))) (/ (log 10) (log im)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (.f64 re re) im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im)))
(fma.f64 (fma.f64 (.f64 #s(literal 1/4 binary64) (+.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (.f64 re re) (.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1/2 binary64))) (.f64 re re) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (+ (* 1/8 (/ (log 10) (* (pow im 6) (pow (log im) 3)))) (* 1/6 (/ (log 10) (* (pow im 6) (pow (log im) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 10) (log im)))
(fma.f64 (fma.f64 (fma.f64 (neg.f64 (.f64 re re)) (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 #s(literal 1/8 binary64) (+.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (.f64 (.f64 (log.f64 im) im) im)))) (.f64 #s(literal 1/4 binary64) (+.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64))))))) (.f64 re re) (.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1/2 binary64))) (*.f64 re re) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(.f64 #s(literal 1/2 binary64) (fma.f64 (/.f64 re (.f64 im im)) (/.f64 re (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))) (.f64 re re)))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))) (.f64 re re) (.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (log (pow im 2)))
(.f64 (log.f64 (.f64 im im)) #s(literal 1/2 binary64))
(+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))
(.f64 #s(literal 1/2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (log.f64 (.f64 im im))))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (log.f64 (.f64 im im)) #s(literal 1/2 binary64) (.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re)))
(+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (log.f64 (.f64 im im)) #s(literal 1/2 binary64) (.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re)))
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(fma.f64 (/.f64 re im) (/.f64 re im) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 im im))) (.f64 re re) (log.f64 (.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/3 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal 1 binary64) (.f64 im im))) (.f64 re re) (log.f64 (*.f64 im im)))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(* -1/2 (/ (log (pow im 2)) (log 1/10)))
(.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(.f64 #s(literal -1/2 binary64) (fma.f64 (/.f64 re (.f64 im im)) (/.f64 re (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64)))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im))) (.f64 re re) (.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64)))
(* -2 (/ (log 1/10) (log (pow im 2))))
(/.f64 (.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (.f64 im im)))
(+ (* -2 (/ (log 1/10) (log (pow im 2)))) (* 2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (pow im 2)) 2)))))
(fma.f64 (.f64 (.f64 re re) #s(literal 2 binary64)) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) (/.f64 (.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (.f64 im im))))
(+ (* -2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* 2 (* (pow re 2) (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* 2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2)))))))
(fma.f64 (.f64 (.f64 re re) #s(literal 2 binary64)) (fma.f64 (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64)))) (.f64 re re) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64)))) (/.f64 (.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (*.f64 im im))))
(+ (* -2 (/ (log 1/10) (log (pow im 2)))) (* (pow re 2) (+ (* 2 (/ (log 1/10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* 2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* 2 (+ (* -1 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow im 4) (pow (log (pow im 2)) 2)))))))))))
(fma.f64 (fma.f64 (.f64 (.f64 re re) #s(literal 2 binary64)) (fma.f64 (fma.f64 (/.f64 #s(literal 1/3 binary64) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64))) #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64)))) (neg.f64 (.f64 (log.f64 (.f64 im im)) (.f64 im im)))))) (.f64 re re) (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64))))) (.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) #s(literal 2 binary64))) (.f64 re re) (/.f64 (.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (.f64 im im))))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(fma.f64 (/.f64 re im) (/.f64 re im) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 im im))) (.f64 re re) (log.f64 (.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/3 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal 1 binary64) (.f64 im im))) (.f64 re re) (log.f64 (*.f64 im im)))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
(/ (log (/ 1 re)) (pow (log 1/10) 3))
(/.f64 (neg.f64 (log.f64 re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (/ (log (/ 1 re)) (pow (log 1/10) 3)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ 1 re)) (pow (log 1/10) 3))))
(fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ 1 re)) (pow (log 1/10) 3)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 re)))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ 1 re))
(neg.f64 (log.f64 re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) re) (/.f64 (*.f64 im im) re) (neg.f64 (log.f64 re)))
(- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64) (neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))))
(- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/720 binary64) (neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log 10) (log (/ 1 re))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))
(+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(fma.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 binary64) (fma.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (*.f64 re re))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(- (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(-.f64 (-.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (fma.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))))) (.f64 im im)) (log.f64 re)) (fma.f64 (.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))) (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) (.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))) (pow.f64 re #s(literal 4 binary64))))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 re)))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64)))) (log.f64 re)))
(* -2 (log (/ 1 re)))
(*.f64 (log.f64 re) #s(literal 2 binary64))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (/.f64 im re) (/.f64 im re) (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 (log.f64 re) #s(literal 2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (log.f64 re) #s(literal 2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
(/ (log 1/10) (log (/ 1 re)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ (log 1/10) (log (/ 1 re))))
(fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re))))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (/ (log 1/10) (log (/ 1 re)))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))))) (pow.f64 re #s(literal 4 binary64))) #s(literal 2 binary64) (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (*.f64 re re))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (/ (log 1/10) (log (/ 1 re))))))
(fma.f64 #s(literal 2 binary64) (+.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (fma.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))))) (.f64 im im)) (log.f64 re)) (fma.f64 (.f64 #s(literal 1/12 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (.f64 (.f64 #s(literal -1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (*.f64 re re))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 re)))))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(* -2 (log (/ 1 re)))
(*.f64 (log.f64 re) #s(literal 2 binary64))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (/.f64 im re) (/.f64 im re) (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 (log.f64 re) #s(literal 2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (log.f64 re) #s(literal 2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(/ (log (/ -1 re)) (pow (log 1/10) 3))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (/ (log (/ -1 re)) (pow (log 1/10) 3)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ -1 re)) (pow (log 1/10) 3))))
(fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log 1/10) 3)))) (/ (log (/ -1 re)) (pow (log 1/10) 3)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ -1 re))
(log.f64 (/.f64 #s(literal -1 binary64) re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re)))
(- (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/720 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (*.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log 10) (log (/ -1 re))))
(/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) re) (/.f64 (.f64 im im) re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) re) (/.f64 (*.f64 im im) re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(-.f64 (-.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (fma.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 (.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (.f64 (.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))))) (neg.f64 (pow.f64 re #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (*.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/6 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(* -2 (log (/ -1 re)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (*.f64 (/.f64 im re) (/.f64 im re)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal -1/6 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(/ (log 1/10) (log (/ -1 re)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ (log 1/10) (log (/ -1 re))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) re) (/.f64 (.f64 im im) re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (/ (log 1/10) (log (/ -1 re)))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (/.f64 (.f64 (.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 re #s(literal 4 binary64))) #s(literal 2 binary64) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) re) (/.f64 (*.f64 im im) re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(+ (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (/ (log 1/10) (log (/ -1 re))))))
(fma.f64 #s(literal 2 binary64) (+.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (/.f64 (.f64 (.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (/.f64 (.f64 (.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 (.f64 #s(literal 1/12 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (/.f64 (.f64 (.f64 #s(literal -1/16 binary64) (pow.f64 im #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) re) (/.f64 (*.f64 im im) re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(pow re 2)
(*.f64 re re)
(* -2 (log (/ -1 re)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (*.f64 (/.f64 im re) (/.f64 im re)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(* -1 (/ (log re) (log 1/10)))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(* -1 (/ (log re) (pow (log 1/10) 3)))
(/.f64 (neg.f64 (log.f64 re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(+ (* -1 (/ (log re) (pow (log 1/10) 3))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log 1/10) 3)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(+ (* -1 (/ (log re) (pow (log 1/10) 3))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (pow (log 1/10) 3)))) (* 1/2 (/ 1 (* (pow re 2) (pow (log 1/10) 3)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(+ (* -1 (/ (log re) (pow (log 1/10) 3))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (pow (log 1/10) 3)))) (* 1/4 (/ 1 (* (pow re 4) (pow (log 1/10) 3)))))) (* 1/2 (/ 1 (* (pow re 2) (pow (log 1/10) 3)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im) (log.f64 re))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(* -1 (/ (log re) (log 1/10)))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(* -1 (log re))
(neg.f64 (log.f64 re))
(- (* -1/2 (/ (pow im 2) (pow re 2))) (log re))
(fma.f64 (/.f64 #s(literal -1/2 binary64) re) (/.f64 (*.f64 im im) re) (neg.f64 (log.f64 re)))
(- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (log re))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64) (/.f64 #s(literal -1/2 binary64) (.f64 re re))) (*.f64 im im) (neg.f64 (log.f64 re)))
(- (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))) (log re))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 re re))) (.f64 im im) (neg.f64 (log.f64 re)))
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) re) re))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) re) re))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(/ (log 10) (log re))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))
(+ (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log re) 2)))) (/ (log 10) (log re)))
(fma.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re)))
(fma.f64 (fma.f64 (.f64 #s(literal 1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (.f64 im im) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) #s(literal -1/2 binary64))) (.f64 im im) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (+ (* 1/8 (/ (log 10) (* (pow re 6) (pow (log re) 3)))) (* 1/6 (/ (log 10) (* (pow re 6) (pow (log re) 2)))))))) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 10) (log re)))
(fma.f64 (fma.f64 (fma.f64 (neg.f64 (.f64 im im)) (fma.f64 (/.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 re) #s(literal 3 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 #s(literal 1/8 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (.f64 (.f64 (log.f64 re) re) re)))) (.f64 #s(literal 1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64))))))) (.f64 im im) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) #s(literal -1/2 binary64))) (.f64 im im) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(.f64 #s(literal 1/2 binary64) (fma.f64 (/.f64 im (log.f64 #s(literal 10 binary64))) (/.f64 im (.f64 re re)) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64) (.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) re) re))) (.f64 im im)))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) re) re))) (.f64 im im) (.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(* 1/2 (log (pow re 2)))
(.f64 (log.f64 (.f64 re re)) #s(literal 1/2 binary64))
(+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))
(.f64 #s(literal 1/2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (log.f64 (.f64 re re))))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (log.f64 (.f64 re re)) #s(literal 1/2 binary64) (.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im)))
(+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (log.f64 (.f64 re re)) #s(literal 1/2 binary64) (.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im)))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(fma.f64 (/.f64 im re) (/.f64 im re) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (log.f64 (.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (log.f64 (*.f64 re re)))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(.f64 #s(literal -1/2 binary64) (fma.f64 (/.f64 im (log.f64 #s(literal 1/10 binary64))) (/.f64 im (.f64 re re)) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64)))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) re) re))) (.f64 im im) (.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64)))
(* -2 (/ (log 1/10) (log (pow re 2))))
(/.f64 (.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (.f64 re re)))
(+ (* -2 (/ (log 1/10) (log (pow re 2)))) (* 2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (pow re 2)) 2)))))
(fma.f64 (.f64 (.f64 im im) #s(literal 2 binary64)) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) (/.f64 (.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (.f64 re re))))
(+ (* -2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* 2 (* (pow im 2) (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* 2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2)))))))
(fma.f64 (.f64 (.f64 im im) #s(literal 2 binary64)) (fma.f64 (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64)))) (.f64 im im) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64)))) (/.f64 (.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (*.f64 re re))))
(+ (* -2 (/ (log 1/10) (log (pow re 2)))) (* (pow im 2) (+ (* 2 (/ (log 1/10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* 2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 1/10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* 2 (+ (* -1 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 1/10) (* (pow re 4) (pow (log (pow re 2)) 2)))))))))))
(fma.f64 (fma.f64 (.f64 (.f64 im im) #s(literal 2 binary64)) (fma.f64 (fma.f64 (/.f64 #s(literal 1/3 binary64) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64))) #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64)))) (neg.f64 (.f64 (log.f64 (.f64 re re)) (.f64 re re)))))) (.f64 im im) (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64))))) (.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 re re)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) #s(literal 2 binary64))) (.f64 im im) (/.f64 (.f64 #s(literal -2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (.f64 re re))))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(fma.f64 (/.f64 im re) (/.f64 im re) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (log.f64 (.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (log.f64 (*.f64 re re)))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))))
(/ (log (/ 1 im)) (pow (log 1/10) 3))
(/.f64 (neg.f64 (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (/ (log (/ 1 im)) (pow (log 1/10) 3)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ 1 im)) (pow (log 1/10) 3))))
(fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ 1 im)) (pow (log 1/10) 3)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64)))) (log.f64 im)))
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(* -1 (log (/ 1 im)))
(log.f64 im)
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))
(-.f64 (.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 (.f64 re re) im)) (log.f64 im))
(- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))))
(- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/720 binary64) (neg.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im)))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (.f64 re re) im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (pow.f64 im #s(literal 4 binary64))) #s(literal -1 binary64) (fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (*.f64 re re) im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(- (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(-.f64 (-.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (/.f64 (fma.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (fma.f64 (.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (fma.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (.f64 re re)) (log.f64 im))))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (.f64 re re) im)) (.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (log.f64 im)))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64)))) (log.f64 im)))
(* -2 (log (/ 1 im)))
(*.f64 #s(literal 2 binary64) (log.f64 im))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))))
(/ (log 1/10) (log (/ 1 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ (log 1/10) (log (/ 1 im))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (.f64 re re) im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im))))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (/ (log 1/10) (log (/ 1 im)))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))) (pow.f64 im #s(literal 4 binary64))) #s(literal 2 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (*.f64 re re) im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (/ (log 1/10) (log (/ 1 im))))))
(fma.f64 #s(literal 2 binary64) (+.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (fma.f64 (.f64 #s(literal -1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (fma.f64 (.f64 #s(literal 1/12 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (fma.f64 (.f64 #s(literal 1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (.f64 (.f64 #s(literal -1/8 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))))) (.f64 re re)) (log.f64 im))))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (*.f64 re re) im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (log.f64 im)))))
(* -2 (log (/ 1 im)))
(*.f64 #s(literal 2 binary64) (log.f64 im))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(/ (log (/ -1 im)) (pow (log 1/10) 3))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (/ (log (/ -1 im)) (pow (log 1/10) 3)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ -1 im)) (pow (log 1/10) 3))))
(fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log 1/10) 3)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (pow (log 1/10) 3)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log 1/10) 3)))) (/ (log (/ -1 im)) (pow (log 1/10) 3)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log -1) (* -1 (log (/ -1 im))))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ -1 im))
(log.f64 (/.f64 #s(literal -1 binary64) im))
(- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im)))
(- (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/720 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (*.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (*.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* -1 (/ (log 10) (log (/ -1 im))))
(/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 im #s(literal 4 binary64))) #s(literal -1 binary64) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (*.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(- (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(-.f64 (-.f64 (/.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 (.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (.f64 (.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))))) (neg.f64 (pow.f64 im #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (fma.f64 (/.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (*.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/6 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(* -2 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal -1/6 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(/ (log 1/10) (log (/ -1 im)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ (log 1/10) (log (/ -1 im))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (/ (log 1/10) (log (/ -1 im)))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (/.f64 (.f64 (.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 im #s(literal 4 binary64))) #s(literal 2 binary64) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (*.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* 2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (/ (log 1/10) (log (/ -1 im))))))
(fma.f64 #s(literal 2 binary64) (+.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (/.f64 (.f64 (.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (fma.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (/.f64 (.f64 (.f64 #s(literal -1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 (.f64 #s(literal 1/12 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (/.f64 (.f64 (.f64 #s(literal -1/16 binary64) (pow.f64 re #s(literal 6 binary64))) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (*.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(* -2 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/3 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))))

rewrite218.0ms (3.1%)

Memory

14.5MiB live, 137.7MiB allocated

Rules

3 844×	`lower-*.f32`
3 834×	`lower-*.f64`
3 062×	`lower-fma.f32`
3 058×	`lower-fma.f64`
2 714×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	39	199
0	62	208
1	183	202
2	955	178
3	7151	178
0	8300	134

Stop Event

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

Counts

21 → 1 276

Calls

Call 1

Inputs
(.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(log.f64 #s(literal 10 binary64))
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
(log.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im)))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64))
(log.f64 #s(literal 1/10 binary64))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
(*.f64 re re)
(log.f64 (fma.f64 re re (*.f64 im im)))

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval463.0ms (6.5%)

Memory: 23.6MiB live, 327.4MiB allocated
Compiler: Compiled 38 076 to 4 660 computations (87.8% saved)

prune94.0ms (1.3%)

Memory

-26.0MiB live, 98.0MiB allocated

Pruning

14 alts after pruning (10 fresh and 4 done)

	Pruned	Kept	Total
New	1 849	8	1 857
Fresh	5	2	7
Picked	2	3	5
Done	0	1	1
Total	1 856	14	1 870

Accuracy

100.0%

Counts

1 870 → 14

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	71.6%	(pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
	98.6%	(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	98.5%	(/.f64 (.f64 (neg.f64 (pow.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
✓	54.1%	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
▶	54.1%	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
	98.5%	(/.f64 (neg.f64 (pow.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #s(literal 2 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))))
✓	98.6%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓	98.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
✓	98.6%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	98.6%	(/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))))
▶	54.1%	(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))))
	54.1%	(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))))
▶	98.6%	(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
▶	99.1%	(.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))

Compiler

Compiled 271 to 256 computations (5.5% saved)

simplify122.0ms (1.7%)

Memory

8.6MiB live, 45.9MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
cost-diff	0	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
cost-diff	5824	(pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
cost-diff	7104	(pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
cost-diff	0	(log.f64 #s(literal 10 binary64))
cost-diff	0	(.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))
cost-diff	128	(/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
cost-diff	704	(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))))
cost-diff	0	(fma.f64 re re (*.f64 im im))
cost-diff	0	(log.f64 (fma.f64 re re (*.f64 im im)))
cost-diff	0	(.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
cost-diff	0	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
cost-diff	0	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
cost-diff	0	(log.f64 #s(literal 1/10 binary64))
cost-diff	0	(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
cost-diff	576	(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
cost-diff	0	(log.f64 #s(literal 1/10 binary64))
cost-diff	0	(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
cost-diff	0	(.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)))
cost-diff	19264	(.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))

Rules

972×	`lower-*.f32`
968×	`lower-fma.f32`
964×	`lower-fma.f64`
960×	`lower-*.f64`
468×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	42	297
0	66	304
1	97	295
2	163	293
3	364	289
4	629	283
5	868	283
6	1170	279
7	1320	279
8	1576	279
9	2110	279
10	2351	279
11	2432	279
12	2566	279
13	2775	279
14	2822	279
15	2834	279
16	2843	279
17	2849	279
18	2859	279
19	2871	279
20	2871	279
0	2871	239

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(literal 2 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))
#s(literal -3 binary64)
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
#s(literal -1 binary64)
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
#s(literal -1/2 binary64)
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
re
(*.f64 im im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))))
#s(literal 1 binary64)
(.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
#s(literal -2 binary64)
(neg.f64 (log.f64 (fma.f64 im im (*.f64 re re))))
(log.f64 (fma.f64 im im (*.f64 re re)))
(fma.f64 im im (*.f64 re re))
im
(*.f64 re re)
re
(pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(literal 1/2 binary64)
#s(literal 2 binary64)

Outputs
(.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)))
(.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(literal 2 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))
#s(literal -3 binary64)
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
#s(literal -1 binary64)
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64))
#s(literal -1/2 binary64)
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
re
(*.f64 im im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (fma.f64 re re (.f64 im im))))
#s(literal 1 binary64)
(.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))
(/.f64 (.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)) (log.f64 (fma.f64 re re (.f64 im im))))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 #s(literal 2 binary64) (log.f64 (fma.f64 re re (*.f64 im im))))
#s(literal -2 binary64)
(neg.f64 (log.f64 (fma.f64 im im (*.f64 re re))))
(neg.f64 (log.f64 (fma.f64 re re (*.f64 im im))))
(log.f64 (fma.f64 im im (*.f64 re re)))
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
im
(*.f64 re re)
re
(pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(sqrt.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(log.f64 im)
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(literal 1/2 binary64)
#s(literal 2 binary64)

localize162.0ms (2.3%)

Memory

-7.1MiB live, 110.2MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.14453125	(pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
accuracy	0.20099182889607065	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.3802337890737681	(pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
accuracy	0.4098625488422102	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
accuracy	0.21484375	(/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
accuracy	0.23046875	(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))))
accuracy	0.4762687988422101	(.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))
accuracy	25.666032563761384	(log.f64 (fma.f64 im im (*.f64 re re)))
accuracy	0	(.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
accuracy	0.4098625488422102	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
accuracy	0.7265625	(log.f64 #s(literal 1/10 binary64))
accuracy	25.666032563761384	(log.f64 (fma.f64 re re (*.f64 im im)))
accuracy	0.20099182889607065	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.23046875	(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
accuracy	0.43787006837909415	(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
accuracy	0.7265625	(log.f64 #s(literal 1/10 binary64))
accuracy	0.4108200195368841	(.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)))
accuracy	0.7265625	(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
accuracy	0.7265625	(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))
accuracy	0.7265625	(log.f64 #s(literal 1/10 binary64))

Samples

103.0ms	186×	0	valid
23.0ms	70×	0	invalid

Compiler

Compiled 289 to 40 computations (86.2% saved)

Precisions

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

ival-div: 47.0ms (44.7% of total)

ival-log: 18.0ms (17.1% of total)

ival-mult: 9.0ms (8.6% of total)

ival-pow2: 7.0ms (6.7% of total)

ival-pow: 6.0ms (5.7% of total)

ival-hypot: 4.0ms (3.8% of total)

const: 4.0ms (3.8% of total)

exact: 4.0ms (3.8% of total)

ival-add: 3.0ms (2.9% of total)

ival-sqrt: 2.0ms (1.9% of total)

ival-neg: 2.0ms (1.9% of total)

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

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

series65.0ms (0.9%)

Memory

21.4MiB live, 57.8MiB allocated

Counts

20 → 384

Calls

Call 1

Inputs
#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())
#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())
#s(alt (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 1/10 binary64)) (patch (log.f64 #s(literal 1/10 binary64)) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())
#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())
#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())
#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())
#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())
#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())
#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 binary64)) #<representation binary64>) () ())
#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())
#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())
#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) (patch (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)) #<representation binary64>) () ())
#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())

Outputs
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor 0 re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (pow (log 1/10) 2) (log im)) (taylor 0 re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))) (* (pow (log 1/10) 2) (log im))) (taylor 0 re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 4))) (* 1/2 (/ (pow (log 1/10) 2) (pow im 2))))) (* (pow (log 1/10) 2) (log im))) (taylor 0 re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* 1/2 (/ (pow (log 1/10) 2) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow (log 1/10) 2) (pow im 4))) (* 1/6 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 6))))))) (* (pow (log 1/10) 2) (log im))) (taylor 0 re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log im) (log 1/10))) (taylor 0 re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor 0 re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (log im)) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log im) 2)))) (/ (log 1/10) (log im))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 1/10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 1/10) (log im))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (+ (* 1/8 (/ (log 1/10) (* (pow im 6) (pow (log im) 3)))) (* 1/6 (/ (log 1/10) (* (pow im 6) (pow (log im) 2)))))))) (+ (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 1/10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 1/10) (log im))) (taylor 0 re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1/2 (/ (log (pow im 2)) (log 1/10))) (taylor 0 re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10))))) (taylor 0 re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10))))))) (taylor 0 re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1/2 (log (pow im 2))) (taylor 0 re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (log (pow im 2))) (* -1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (log (pow im 2)) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow im 2)) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10))))))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (/ 2 (log (pow im 2))) (taylor 0 re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (pow re 2) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ 1 (log (pow im 2))))) (taylor 0 re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* (pow re 2) (+ (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2))) (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2))))) (taylor 0 re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 2/3 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 2)))) (+ (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 3)))) (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2))))) (taylor 0 re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (log 10) (log (pow im 2)))) (taylor 0 re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ (log 10) (log (pow im 2))))) (taylor 0 re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2))))))) (taylor 0 re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))))))))) (taylor 0 re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (sqrt (/ (log im) (log 10))) (taylor 0 re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (sqrt (/ (log im) (log 10))) (* 1/4 (* (/ (pow re 2) (pow im 2)) (sqrt (/ 1 (* (log 10) (log im))))))) (taylor 0 re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (sqrt (/ (log im) (log 10))) (* (pow re 2) (+ (* -1/2 (* (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (log im))))))) (sqrt (/ (log 10) (log im))))) (* 1/4 (* (/ 1 (pow im 2)) (sqrt (/ 1 (* (log 10) (log im))))))))) (taylor 0 re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (sqrt (/ (log im) (log 10))) (* (pow re 2) (+ (* 1/4 (* (/ 1 (pow im 2)) (sqrt (/ 1 (* (log 10) (log im)))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log im))) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (log im)))))))) (* 1/2 (* (* (pow re 2) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (log im)))))) (* (pow im 2) (log im)))))) (sqrt (/ (log 10) (log im)))))))))) (taylor 0 re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (pow im 2)) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2))))) (taylor 0 re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 re)) (log 1/10)) (taylor inf re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))) (taylor inf re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))) (taylor inf re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))) (taylor inf re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (pow (log 1/10) 2) (log (/ 1 re)))) (taylor inf re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2)))) (taylor inf re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))))) (taylor inf re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2)))))) (taylor inf re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 re)) (log 1/10)) (taylor inf re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))) (taylor inf re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))) (taylor inf re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))) (taylor inf re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 1/10) (log (/ 1 re)))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))) (taylor inf re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 re)) (log 1/10)) (taylor inf re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))) (taylor inf re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))) (taylor inf re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))) (taylor inf re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ 1 re)) (taylor inf re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1 re)) (* -1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4))))) (taylor inf re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4)))))) (taylor inf re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ 1 re))) (taylor inf re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))) (taylor inf re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))) (taylor inf re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))))) (taylor inf re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 re)))) (taylor inf re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))) (taylor inf re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))) (taylor inf re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))) (taylor inf re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)) (taylor inf re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))) (taylor inf re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))) (taylor inf re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2))))))) (* (log (/ 1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))))) (taylor inf re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 re)) (log 1/10)) (taylor -inf re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))) (taylor -inf re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))) (taylor -inf re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))) (taylor -inf re) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (pow (log 1/10) 2) (log (/ -1 re)))) (taylor -inf re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2)))) (taylor -inf re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))))) (taylor -inf re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2)))))) (taylor -inf re) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 re)) (log 1/10)) (taylor -inf re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))) (taylor -inf re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))) (taylor -inf re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))) (taylor -inf re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 1/10) (log (/ -1 re)))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))) (taylor -inf re) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 re)) (log 1/10)) (taylor -inf re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))) (taylor -inf re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))) (taylor -inf re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))) (taylor -inf re) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ -1 re)) (taylor -inf re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ -1 re)) (* -1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4))))) (taylor -inf re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4)))))) (taylor -inf re) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))) (taylor -inf re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))) (taylor -inf re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))))) (taylor -inf re) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ -1 re)))) (taylor -inf re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))) (taylor -inf re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))) (taylor -inf re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))) (taylor -inf re) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)) (taylor -inf re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))) (taylor -inf re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))) (taylor -inf re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2))))))) (* (log (/ -1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))))) (taylor -inf re) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))) (taylor -inf re) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log re) (log 1/10))) (taylor 0 im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10))))) (taylor 0 im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* (pow (log 1/10) 2) (log re)) (taylor 0 im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))) (* (pow (log 1/10) 2) (log re))) (taylor 0 im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 4))) (* 1/2 (/ (pow (log 1/10) 2) (pow re 2))))) (* (pow (log 1/10) 2) (log re))) (taylor 0 im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* 1/2 (/ (pow (log 1/10) 2) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow (log 1/10) 2) (pow re 4))) (* 1/6 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 6))))))) (* (pow (log 1/10) 2) (log re))) (taylor 0 im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log re) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10))))) (taylor 0 im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (/ (log 1/10) (log re)) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log re) 2)))) (/ (log 1/10) (log re))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 1/10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 1/10) (log re))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (+ (* 1/8 (/ (log 1/10) (* (pow re 6) (pow (log re) 3)))) (* 1/6 (/ (log 1/10) (* (pow re 6) (pow (log re) 2)))))))) (+ (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 1/10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 1/10) (log re))) (taylor 0 im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (* -1/2 (/ (log (pow re 2)) (log 1/10))) (taylor 0 im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10))))) (taylor 0 im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10))))))) (taylor 0 im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1/2 (log (pow re 2))) (taylor 0 im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (log (pow re 2))) (* -1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2)))))) (taylor 0 im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (log (pow re 2)) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (log (pow re 2)) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10))))))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (/ 2 (log (pow re 2))) (taylor 0 im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (pow im 2) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ 1 (log (pow re 2))))) (taylor 0 im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (- (* (pow im 2) (+ (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2))) (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2))))) (taylor 0 im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 2/3 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 2)))) (+ (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 3)))) (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2))))) (taylor 0 im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (log 10) (log (pow re 2)))) (taylor 0 im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ (log 10) (log (pow re 2))))) (taylor 0 im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2))))))) (taylor 0 im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))))))))) (taylor 0 im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (/ (log re) (log 10)) (taylor 0 im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (sqrt (/ (log re) (log 10))) (taylor 0 im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (sqrt (/ (log re) (log 10))) (* 1/4 (* (/ (pow im 2) (pow re 2)) (sqrt (/ 1 (* (log 10) (log re))))))) (taylor 0 im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (sqrt (/ (log re) (log 10))) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (log re))))))) (sqrt (/ (log 10) (log re))))) (* 1/4 (* (/ 1 (pow re 2)) (sqrt (/ 1 (* (log 10) (log re))))))))) (taylor 0 im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (sqrt (/ (log re) (log 10))) (* (pow im 2) (+ (* 1/4 (* (/ 1 (pow re 2)) (sqrt (/ 1 (* (log 10) (log re)))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log re))) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (log re)))))))) (* 1/2 (* (* (pow im 2) (- (* 1/6 (/ 1 (* (pow re 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (log re)))))) (* (pow re 2) (log re)))))) (sqrt (/ (log 10) (log re)))))))))) (taylor 0 im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (/ (log re) (log 10)) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (pow re 2)) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2))))) (taylor 0 im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))) (taylor inf im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))) (taylor inf im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))) (taylor inf im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (pow (log 1/10) 2) (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2)))) (taylor inf im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))))) (taylor inf im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2)))))) (taylor inf im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))) (taylor inf im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))) (taylor inf im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))) (taylor inf im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 1/10) (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))) (taylor inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ 1 im)) (log 1/10)) (taylor inf im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))) (taylor inf im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))) (taylor inf im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))) (taylor inf im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ 1 im)) (taylor inf im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1 im)) (* -1/2 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4))))) (taylor inf im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4)))))) (taylor inf im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ 1 im))) (taylor inf im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))) (taylor inf im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))) (taylor inf im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))))) (taylor inf im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ 1 im)))) (taylor inf im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))) (taylor inf im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))) (taylor inf im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)) (taylor inf im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))) (taylor inf im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))) (taylor inf im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2))))))) (* (log (/ 1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))))) (taylor inf im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 im)) (log 1/10)) (taylor -inf im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))) (taylor -inf im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))) (taylor -inf im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))) (taylor -inf im) (#s(alt (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) (patch (.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* (pow (log 1/10) 2) (log (/ -1 im)))) (taylor -inf im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2)))) (taylor -inf im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))))) (taylor -inf im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2)))))) (taylor -inf im) (#s(alt (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (patch (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 im)) (log 1/10)) (taylor -inf im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))) (taylor -inf im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))) (taylor -inf im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 1/10) (log (/ -1 im)))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))) (taylor -inf im) (#s(alt (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #<representation binary64>) () ())) ())
#s(alt (/ (log (/ -1 im)) (log 1/10)) (taylor -inf im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))) (taylor -inf im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))) (taylor -inf im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))) (taylor -inf im) (#s(alt (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log (/ -1 im)) (taylor -inf im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ -1 im)) (* -1/2 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4))))) (taylor -inf im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4)))))) (taylor -inf im) (#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 re re (.f64 im im))) (patch (log.f64 (fma.f64 re re (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (fma.f64 re re (.f64 im im)) (patch (fma.f64 re re (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) (patch (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log (/ -1 im))) (taylor -inf im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))) (taylor -inf im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))) (taylor -inf im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))))) (taylor -inf im) (#s(alt (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) (patch (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log 10) (log (/ -1 im)))) (taylor -inf im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))) (taylor -inf im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))) (taylor -inf im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))) (taylor -inf im) (#s(alt (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) (patch (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) (patch (pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)) (taylor -inf im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))) (taylor -inf im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))) (taylor -inf im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2))))))) (* (log (/ -1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))))) (taylor -inf im) (#s(alt (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) (patch (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))) (taylor -inf im) (#s(alt (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -2 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())
#s(alt (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2))))) (taylor -inf im) (#s(alt (log.f64 (fma.f64 im im (.f64 re re))) (patch (log.f64 (fma.f64 im im (.f64 re re))) #<representation binary64>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
20.0ms	im	@	inf	((* (* (pow (log 1/10) 2) (log (sqrt (+ (* re re) (* im im))))) (neg (pow (log 1/10) -3))) (* (pow (log 1/10) 2) (log (sqrt (+ (* re re) (* im im))))) (pow (log 1/10) 2) (log 1/10) (/ -1 (/ (log 1/10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 1/10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10)) (* -1/2 (log (+ (* re re) (* im im)))) (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ 1 (* (log 10) (/ -2 (neg (log (+ (* im im) (* re re))))))) (/ -2 (neg (log (+ (* im im) (* re re))))) (* (log 10) (/ -2 (neg (log (+ (* im im) (* re re)))))) (log 10) (pow (pow (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) 1/2) 2) (pow (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) 1/2) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (pow (log 1/10) -3) (log (+ (* im im) (* re re))))
7.0ms	re	@	inf	((* (* (pow (log 1/10) 2) (log (sqrt (+ (* re re) (* im im))))) (neg (pow (log 1/10) -3))) (* (pow (log 1/10) 2) (log (sqrt (+ (* re re) (* im im))))) (pow (log 1/10) 2) (log 1/10) (/ -1 (/ (log 1/10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 1/10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10)) (* -1/2 (log (+ (* re re) (* im im)))) (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ 1 (* (log 10) (/ -2 (neg (log (+ (* im im) (* re re))))))) (/ -2 (neg (log (+ (* im im) (* re re))))) (* (log 10) (/ -2 (neg (log (+ (* im im) (* re re)))))) (log 10) (pow (pow (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) 1/2) 2) (pow (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) 1/2) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (pow (log 1/10) -3) (log (+ (* im im) (* re re))))
6.0ms	re	@	0	((* (* (pow (log 1/10) 2) (log (sqrt (+ (* re re) (* im im))))) (neg (pow (log 1/10) -3))) (* (pow (log 1/10) 2) (log (sqrt (+ (* re re) (* im im))))) (pow (log 1/10) 2) (log 1/10) (/ -1 (/ (log 1/10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 1/10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10)) (* -1/2 (log (+ (* re re) (* im im)))) (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ 1 (* (log 10) (/ -2 (neg (log (+ (* im im) (* re re))))))) (/ -2 (neg (log (+ (* im im) (* re re))))) (* (log 10) (/ -2 (neg (log (+ (* im im) (* re re)))))) (log 10) (pow (pow (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) 1/2) 2) (pow (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) 1/2) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (pow (log 1/10) -3) (log (+ (* im im) (* re re))))
5.0ms	im	@	0	((* (* (pow (log 1/10) 2) (log (sqrt (+ (* re re) (* im im))))) (neg (pow (log 1/10) -3))) (* (pow (log 1/10) 2) (log (sqrt (+ (* re re) (* im im))))) (pow (log 1/10) 2) (log 1/10) (/ -1 (/ (log 1/10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 1/10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10)) (* -1/2 (log (+ (* re re) (* im im)))) (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ 1 (* (log 10) (/ -2 (neg (log (+ (* im im) (* re re))))))) (/ -2 (neg (log (+ (* im im) (* re re))))) (* (log 10) (/ -2 (neg (log (+ (* im im) (* re re)))))) (log 10) (pow (pow (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) 1/2) 2) (pow (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) 1/2) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (pow (log 1/10) -3) (log (+ (* im im) (* re re))))
5.0ms	re	@	-inf	((* (* (pow (log 1/10) 2) (log (sqrt (+ (* re re) (* im im))))) (neg (pow (log 1/10) -3))) (* (pow (log 1/10) 2) (log (sqrt (+ (* re re) (* im im))))) (pow (log 1/10) 2) (log 1/10) (/ -1 (/ (log 1/10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 1/10) (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10)) (* -1/2 (log (+ (* re re) (* im im)))) (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (/ 1 (* (log 10) (/ -2 (neg (log (+ (* im im) (* re re))))))) (/ -2 (neg (log (+ (* im im) (* re re))))) (* (log 10) (/ -2 (neg (log (+ (* im im) (* re re)))))) (log 10) (pow (pow (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) 1/2) 2) (pow (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) 1/2) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (pow (log 1/10) -3) (log (+ (* im im) (* re re))))

simplify368.0ms (5.2%)

Memory

-36.4MiB live, 264.4MiB allocated

Algorithm

1×	egg-herbie

Rules

7 092×	`lower-fma.f64`
7 092×	`lower-fma.f32`
6 618×	`lower-*.f64`
6 618×	`lower-*.f32`
5 140×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1340	12108
1	4093	11726
0	8310	11214

Stop Event

1×	iter limit
1×	node limit

Counts

384 → 384

Calls

Call 1

Inputs
(* -1 (/ (log im) (log 1/10)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(* (pow (log 1/10) 2) (log im))
(+ (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))) (* (pow (log 1/10) 2) (log im)))
(+ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 4))) (* 1/2 (/ (pow (log 1/10) 2) (pow im 2))))) (* (pow (log 1/10) 2) (log im)))
(+ (* (pow re 2) (+ (* 1/2 (/ (pow (log 1/10) 2) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow (log 1/10) 2) (pow im 4))) (* 1/6 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 6))))))) (* (pow (log 1/10) 2) (log im)))
(* -1 (/ (log im) (log 1/10)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(/ (log 1/10) (log im))
(+ (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log im) 2)))) (/ (log 1/10) (log im)))
(+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 1/10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 1/10) (log im)))
(+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (+ (* 1/8 (/ (log 1/10) (* (pow im 6) (pow (log im) 3)))) (* 1/6 (/ (log 1/10) (* (pow im 6) (pow (log im) 2)))))))) (+ (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 1/10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 1/10) (log im)))
(log im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(* -1/2 (/ (log (pow im 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(* -1/2 (log (pow im 2)))
(+ (* -1/2 (log (pow im 2))) (* -1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(pow im 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(/ 2 (log (pow im 2)))
(+ (* -2 (/ (pow re 2) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ 1 (log (pow im 2)))))
(+ (* (pow re 2) (- (* (pow re 2) (+ (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2))) (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(+ (* (pow re 2) (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 2/3 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 2)))) (+ (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 3)))) (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(* 2 (/ (log 10) (log (pow im 2))))
(+ (* -2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ (log 10) (log (pow im 2)))))
(+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2)))))))
(+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2)))))))))))
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(sqrt (/ (log im) (log 10)))
(+ (sqrt (/ (log im) (log 10))) (* 1/4 (* (/ (pow re 2) (pow im 2)) (sqrt (/ 1 (* (log 10) (log im)))))))
(+ (sqrt (/ (log im) (log 10))) (* (pow re 2) (+ (* -1/2 (* (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (log im))))))) (sqrt (/ (log 10) (log im))))) (* 1/4 (* (/ 1 (pow im 2)) (sqrt (/ 1 (* (log 10) (log im)))))))))
(+ (sqrt (/ (log im) (log 10))) (* (pow re 2) (+ (* 1/4 (* (/ 1 (pow im 2)) (sqrt (/ 1 (* (log 10) (log im)))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log im))) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (log im)))))))) (* 1/2 (* (* (pow re 2) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (log im)))))) (* (pow im 2) (log im)))))) (sqrt (/ (log 10) (log im))))))))))
(/ (log im) (log 10))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(log (pow im 2))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(* -1 (* (pow (log 1/10) 2) (log (/ 1 re))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2)))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(* -1 (/ (log 1/10) (log (/ 1 re))))
(+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(- (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(- (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(* -1 (log (/ 1 re)))
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(/ (log (/ 1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(log (/ 1 re))
(+ (log (/ 1 re)) (* -1/2 (/ (pow im 2) (pow re 2))))
(+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4)))))
(+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4))))))
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(/ -1 (log (/ 1 re)))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))
(* -1 (/ (log 10) (log (/ 1 re))))
(+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2))))))) (* (log (/ 1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -2 (log (/ 1 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(* -1 (* (pow (log 1/10) 2) (log (/ -1 re))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2)))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(* -1 (/ (log 1/10) (log (/ -1 re))))
(+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(- (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(- (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(* -1 (log (/ -1 re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(/ (log (/ -1 re)) (log 1/10))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(log (/ -1 re))
(+ (log (/ -1 re)) (* -1/2 (/ (pow im 2) (pow re 2))))
(+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4)))))
(+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4))))))
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(pow re 2)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(/ -1 (log (/ -1 re)))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))))
(* -1 (/ (log 10) (log (/ -1 re))))
(+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2))))))) (* (log (/ -1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(* -2 (log (/ -1 re)))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(* -1 (/ (log re) (log 1/10)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(* (pow (log 1/10) 2) (log re))
(+ (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))) (* (pow (log 1/10) 2) (log re)))
(+ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 4))) (* 1/2 (/ (pow (log 1/10) 2) (pow re 2))))) (* (pow (log 1/10) 2) (log re)))
(+ (* (pow im 2) (+ (* 1/2 (/ (pow (log 1/10) 2) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow (log 1/10) 2) (pow re 4))) (* 1/6 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 6))))))) (* (pow (log 1/10) 2) (log re)))
(* -1 (/ (log re) (log 1/10)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(/ (log 1/10) (log re))
(+ (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log re) 2)))) (/ (log 1/10) (log re)))
(+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 1/10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 1/10) (log re)))
(+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (+ (* 1/8 (/ (log 1/10) (* (pow re 6) (pow (log re) 3)))) (* 1/6 (/ (log 1/10) (* (pow re 6) (pow (log re) 2)))))))) (+ (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 1/10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 1/10) (log re)))
(log re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(* -1/2 (log (pow re 2)))
(+ (* -1/2 (log (pow re 2))) (* -1/2 (/ (pow im 2) (pow re 2))))
(+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(pow re 2)
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(+ (pow im 2) (pow re 2))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(/ 2 (log (pow re 2)))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ 1 (log (pow re 2)))))
(+ (* (pow im 2) (- (* (pow im 2) (+ (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2))) (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(+ (* (pow im 2) (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 2/3 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 2)))) (+ (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 3)))) (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(* 2 (/ (log 10) (log (pow re 2))))
(+ (* -2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ (log 10) (log (pow re 2)))))
(+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2)))))))
(+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2)))))))))))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(sqrt (/ (log re) (log 10)))
(+ (sqrt (/ (log re) (log 10))) (* 1/4 (* (/ (pow im 2) (pow re 2)) (sqrt (/ 1 (* (log 10) (log re)))))))
(+ (sqrt (/ (log re) (log 10))) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (log re))))))) (sqrt (/ (log 10) (log re))))) (* 1/4 (* (/ 1 (pow re 2)) (sqrt (/ 1 (* (log 10) (log re)))))))))
(+ (sqrt (/ (log re) (log 10))) (* (pow im 2) (+ (* 1/4 (* (/ 1 (pow re 2)) (sqrt (/ 1 (* (log 10) (log re)))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log re))) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (log re)))))))) (* 1/2 (* (* (pow im 2) (- (* 1/6 (/ 1 (* (pow re 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (log re)))))) (* (pow re 2) (log re)))))) (sqrt (/ (log 10) (log re))))))))))
(/ (log re) (log 10))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(log (pow re 2))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(* -1 (* (pow (log 1/10) 2) (log (/ 1 im))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2)))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(- (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(- (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(* -1 (log (/ 1 im)))
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(/ (log (/ 1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(log (/ 1 im))
(+ (log (/ 1 im)) (* -1/2 (/ (pow re 2) (pow im 2))))
(+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4)))))
(+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4))))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(/ -1 (log (/ 1 im)))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))
(* -1 (/ (log 10) (log (/ 1 im))))
(+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2))))))) (* (log (/ 1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(* -1 (* (pow (log 1/10) 2) (log (/ -1 im))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2)))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(* -1 (/ (log 1/10) (log (/ -1 im))))
(+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(- (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(- (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(* -1 (log (/ -1 im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(/ (log (/ -1 im)) (log 1/10))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(log (/ -1 im))
(+ (log (/ -1 im)) (* -1/2 (/ (pow re 2) (pow im 2))))
(+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4)))))
(+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4))))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(pow im 2)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(/ -1 (log (/ -1 im)))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))
(* -1 (/ (log 10) (log (/ -1 im))))
(+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2))))))) (* (log (/ -1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(* -2 (log (/ -1 im)))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))

Outputs
(* -1 (/ (log im) (log 1/10)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(* (pow (log 1/10) 2) (log im))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))
(+ (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))) (* (pow (log 1/10) 2) (log im)))
(fma.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) im) (/.f64 (.f64 re re) im)) #s(literal 1/2 binary64) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)))
(+ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 4))) (* 1/2 (/ (pow (log 1/10) 2) (pow im 2))))) (* (pow (log 1/10) 2) (log im)))
(fma.f64 (fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (.f64 im im)) #s(literal 1/2 binary64) (.f64 (/.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (.f64 re re)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64))) (.f64 re re) (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)))
(+ (* (pow re 2) (+ (* 1/2 (/ (pow (log 1/10) 2) (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow (log 1/10) 2) (pow im 4))) (* 1/6 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 6))))))) (* (pow (log 1/10) 2) (log im)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (.f64 re re)) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) im))) (.f64 re re) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)))
(* -1 (/ (log im) (log 1/10)))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log im) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log im) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(/ (log 1/10) (log im))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(+ (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log im) 2)))) (/ (log 1/10) (log im)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (.f64 re re) im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(+ (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 1/10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 1/10) (log im)))
(fma.f64 (fma.f64 (.f64 #s(literal 1/4 binary64) (+.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (.f64 re re) (.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1/2 binary64))) (.f64 re re) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(+ (* (pow re 2) (- (* (pow re 2) (- (* -1 (* (pow re 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 3))))) (* (pow im 2) (log im)))) (+ (* 1/8 (/ (log 1/10) (* (pow im 6) (pow (log im) 3)))) (* 1/6 (/ (log 1/10) (* (pow im 6) (pow (log im) 2)))))))) (+ (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 1/10) (* (pow im 4) (pow (log im) 3))))))) (* 1/2 (/ (log 1/10) (* (pow im 2) (pow (log im) 2)))))) (/ (log 1/10) (log im)))
(fma.f64 (fma.f64 (neg.f64 (fma.f64 (fma.f64 (/.f64 (.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))))) (.f64 (.f64 im im) (log.f64 im))) #s(literal -1/2 binary64) (fma.f64 (/.f64 #s(literal 1/8 binary64) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (.f64 re re) (.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))))))) (.f64 re re) (.f64 (/.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1/2 binary64))) (*.f64 re re) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(log im)
(log.f64 im)
(+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re) (log.f64 im))
(+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re) (log.f64 im))
(* -1/2 (/ (log (pow im 2)) (log 1/10)))
(.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))
(.f64 #s(literal -1/2 binary64) (fma.f64 (/.f64 re (log.f64 #s(literal 1/10 binary64))) (/.f64 re (.f64 im im)) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64)))
(+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64)))
(* -1/2 (log (pow im 2)))
(.f64 (log.f64 (.f64 im im)) #s(literal -1/2 binary64))
(+ (* -1/2 (log (pow im 2))) (* -1/2 (/ (pow re 2) (pow im 2))))
(.f64 #s(literal -1/2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (log.f64 (.f64 im im))))
(+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64) (/.f64 #s(literal -1/2 binary64) (.f64 im im))) (.f64 re re) (.f64 (log.f64 (*.f64 im im)) #s(literal -1/2 binary64)))
(+ (* -1/2 (log (pow im 2))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal -1/2 binary64) (.f64 im im))) (.f64 re re) (.f64 (log.f64 (.f64 im im)) #s(literal -1/2 binary64)))
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(fma.f64 (/.f64 re im) (/.f64 re im) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 im im))) (.f64 re re) (log.f64 (.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/3 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal 1 binary64) (.f64 im im))) (.f64 re re) (log.f64 (*.f64 im im)))
(pow im 2)
(*.f64 im im)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(* 1/2 (/ (log (pow im 2)) (log 10)))
(.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(.f64 #s(literal 1/2 binary64) (fma.f64 (/.f64 re (.f64 im im)) (/.f64 re (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (*.f64 im im)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)))) (.f64 re re) (.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)))) (.f64 re re) (.f64 (/.f64 (log.f64 (.f64 im im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(/ 2 (log (pow im 2)))
(/.f64 #s(literal 2 binary64) (log.f64 (*.f64 im im)))
(+ (* -2 (/ (pow re 2) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ 1 (log (pow im 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 re im) (/.f64 re im)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) #s(literal -2 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (*.f64 im im))))
(+ (* (pow re 2) (- (* (pow re 2) (+ (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2))) (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(fma.f64 (fma.f64 (+.f64 (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64)))) (.f64 re re) (/.f64 #s(literal -2 binary64) (.f64 (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64)) (.f64 im im)))) (.f64 re re) (/.f64 #s(literal 2 binary64) (log.f64 (*.f64 im im))))
(+ (* (pow re 2) (- (* (pow re 2) (+ (* -1 (* (pow re 2) (+ (* 2/3 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 2)))) (+ (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 3)))) (* 2 (/ 1 (* (pow im 6) (pow (log (pow im 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow im 4) (pow (log (pow im 2)) 3)))) (/ 1 (* (pow im 4) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (* (pow im 2) (pow (log (pow im 2)) 2)))))) (* 2 (/ 1 (log (pow im 2)))))
(fma.f64 (fma.f64 (fma.f64 (neg.f64 (.f64 re re)) (+.f64 (+.f64 (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 (log.f64 (.f64 im im)) #s(literal 4 binary64)) (pow.f64 im #s(literal 6 binary64)))) (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64))))) (/.f64 #s(literal 2/3 binary64) (.f64 (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64)) (pow.f64 im #s(literal 6 binary64))))) (+.f64 (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 (/.f64 #s(literal 1 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))))) (.f64 re re) (/.f64 #s(literal -2 binary64) (.f64 (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64)) (.f64 im im)))) (.f64 re re) (/.f64 #s(literal 2 binary64) (log.f64 (.f64 im im))))
(* 2 (/ (log 10) (log (pow im 2))))
(/.f64 (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (.f64 im im)))
(+ (* -2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* 2 (/ (log 10) (log (pow im 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (.f64 re re) im)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) #s(literal -2 binary64) (/.f64 (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 im im))))
(+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))))) (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2)))))))
(fma.f64 (.f64 #s(literal -2 binary64) (fma.f64 (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64)))) (.f64 re re) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))))) (.f64 re re) (/.f64 (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 im im))))
(+ (* 2 (/ (log 10) (log (pow im 2)))) (* (pow re 2) (+ (* -2 (/ (log 10) (* (pow im 2) (pow (log (pow im 2)) 2)))) (* (pow re 2) (+ (* -2 (* (pow re 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2))))) (* (pow im 2) (log (pow im 2))))) (+ (* 1/3 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 2)))) (* 1/2 (/ (log 10) (* (pow im 6) (pow (log (pow im 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 3)))) (* -1/2 (/ (log 10) (* (pow im 4) (pow (log (pow im 2)) 2)))))))))))
(fma.f64 (fma.f64 (.f64 #s(literal -2 binary64) (fma.f64 (-.f64 (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64))) #s(literal 1/2 binary64) (.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) #s(literal 1/3 binary64))) (/.f64 (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64)))) (.f64 (log.f64 (.f64 im im)) (.f64 im im)))) (.f64 re re) (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 im im)) #s(literal 3 binary64)))))) (.f64 re re) (.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)) (pow.f64 (log.f64 (.f64 im im)) #s(literal 2 binary64))) #s(literal -2 binary64))) (.f64 re re) (/.f64 (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 im im))))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(sqrt (/ (log im) (log 10)))
(sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (sqrt (/ (log im) (log 10))) (* 1/4 (* (/ (pow re 2) (pow im 2)) (sqrt (/ 1 (* (log 10) (log im)))))))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 re im) (/.f64 re im))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))) (sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (sqrt (/ (log im) (log 10))) (* (pow re 2) (+ (* -1/2 (* (* (pow re 2) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (log im))))))) (sqrt (/ (log 10) (log im))))) (* 1/4 (* (/ 1 (pow im 2)) (sqrt (/ 1 (* (log 10) (log im)))))))))
(fma.f64 (fma.f64 (/.f64 (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))) (.f64 im im)) #s(literal 1/4 binary64) (.f64 (.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))) (.f64 (+.f64 (/.f64 #s(literal 1/16 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 re re))) #s(literal -1/2 binary64))) (*.f64 re re) (sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(+ (sqrt (/ (log im) (log 10))) (* (pow re 2) (+ (* 1/4 (* (/ 1 (pow im 2)) (sqrt (/ 1 (* (log 10) (log im)))))) (* (pow re 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log im))) (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (log im)))))))) (* 1/2 (* (* (pow re 2) (- (* 1/6 (/ 1 (* (pow im 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow im 4) (log 10)))) (* 1/16 (/ 1 (* (pow im 4) (* (log 10) (log im)))))) (* (pow im 2) (log im)))))) (sqrt (/ (log 10) (log im))))))))))
(fma.f64 (fma.f64 (fma.f64 (.f64 (.f64 re re) (.f64 (-.f64 (/.f64 #s(literal 1/6 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64)))) (.f64 (/.f64 (+.f64 (/.f64 #s(literal 1/16 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 (.f64 im im) (log.f64 im))) #s(literal -1/4 binary64))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))) #s(literal 1/2 binary64) (.f64 (.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))) (+.f64 (/.f64 #s(literal 1/16 binary64) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (pow.f64 im #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))))) (.f64 re re) (.f64 (/.f64 (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 im))) (.f64 im im)) #s(literal 1/4 binary64))) (*.f64 re re) (sqrt.f64 (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(/ (log im) (log 10))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(log (pow im 2))
(log.f64 (*.f64 im im))
(+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))
(fma.f64 (/.f64 re im) (/.f64 re im) (log.f64 (*.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))
(fma.f64 (fma.f64 (/.f64 (.f64 re re) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 im im))) (.f64 re re) (log.f64 (.f64 im im)))
(+ (log (pow im 2)) (* (pow re 2) (+ (* (pow re 2) (- (* 1/3 (/ (pow re 2) (pow im 6))) (* 1/2 (/ 1 (pow im 4))))) (/ 1 (pow im 2)))))
(fma.f64 (fma.f64 (fma.f64 #s(literal 1/3 binary64) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64)))) (.f64 re re) (/.f64 #s(literal 1 binary64) (.f64 im im))) (.f64 re re) (log.f64 (*.f64 im im)))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (* (pow (log 1/10) 2) (log (/ 1 re))))
(*.f64 (log.f64 re) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 re)))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))))
(fma.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) re) (/.f64 (.f64 im im) re)) #s(literal 1/2 binary64) (*.f64 (log.f64 re) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2)))))
(fma.f64 (log.f64 re) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) re) (/.f64 (.f64 im im) re)) #s(literal 1/2 binary64))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))))))
(fma.f64 (log.f64 re) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) re) (/.f64 (.f64 im im) re)) #s(literal 1/2 binary64)))))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (/ (log 1/10) (log (/ 1 re))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re))
(+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(fma.f64 (.f64 (/.f64 (.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re)))
(- (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(-.f64 (-.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re)) (/.f64 (fma.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) #s(literal 1/4 binary64) (.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) #s(literal -1/4 binary64))) (pow.f64 re #s(literal 4 binary64)))) (.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) re) (/.f64 (.f64 im im) re))))
(- (+ (* -1 (/ (log 1/10) (log (/ 1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 1/10)) (pow (log (/ 1 re)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(-.f64 (-.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re)) (/.f64 (fma.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) #s(literal -1/8 binary64) (fma.f64 (.f64 (.f64 im im) (/.f64 (fma.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) #s(literal 1/4 binary64) (.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) #s(literal -1/4 binary64))) (neg.f64 (log.f64 re)))) #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) #s(literal 1/720 binary64)))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) re) (/.f64 (.f64 im im) re)) (.f64 (/.f64 #s(literal 1/4 binary64) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (/.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 re #s(literal 4 binary64)))))))
(* -1 (log (/ 1 re)))
(log.f64 re)
(+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(+.f64 (log.f64 re) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(+.f64 (log.f64 re) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))))))
(/ (log (/ 1 re)) (log 1/10))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ 1 re))
(neg.f64 (log.f64 re))
(+ (log (/ 1 re)) (* -1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) re) (/.f64 (*.f64 im im) re) (neg.f64 (log.f64 re)))
(+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4)))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) (log.f64 re))
(+ (log (/ 1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4))))))
(-.f64 (fma.f64 (.f64 (/.f64 im re) (/.f64 im re)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/6 binary64) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))) (log.f64 re))
(* -2 (log (/ 1 re)))
(neg.f64 (*.f64 #s(literal -2 binary64) (log.f64 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (/.f64 im re) (/.f64 im re) (neg.f64 (*.f64 #s(literal -2 binary64) (log.f64 re))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(/ -1 (log (/ 1 re)))
(/.f64 #s(literal 1 binary64) (log.f64 re))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re))))
(fma.f64 (/.f64 (.f64 im im) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 re)))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) (neg.f64 (pow.f64 re #s(literal 4 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (*.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 re)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (/ 1 (log (/ 1 re)))))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) #s(literal -1/8 binary64) (fma.f64 (.f64 (.f64 im im) (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) (neg.f64 (log.f64 re)))) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 re) #s(literal 2 binary64))))) (neg.f64 (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (neg.f64 (/.f64 #s(literal 1 binary64) (log.f64 re)))))))
(* -1 (/ (log 10) (log (/ 1 re))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))
(+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(fma.f64 (.f64 (/.f64 (.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2))))))
(fma.f64 (/.f64 (fma.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) #s(literal 1/8 binary64) (.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) #s(literal -1/8 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -2 binary64) (fma.f64 (.f64 (/.f64 (.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ 1 re)) 3))))) (log (/ 1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ 1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ 1 re)) 2)))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (fma.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) #s(literal 1/8 binary64) (.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) #s(literal -1/8 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (fma.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) #s(literal -1/16 binary64) (fma.f64 (.f64 (.f64 im im) (/.f64 (fma.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) #s(literal 1/8 binary64) (.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) #s(literal -1/8 binary64))) (neg.f64 (log.f64 re)))) #s(literal 1/2 binary64) (.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) #s(literal 1/12 binary64)))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (.f64 (/.f64 (.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 im (sqrt.f64 #s(literal -1 binary64))) (/.f64 im (.f64 re re)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 re)))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64))))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1))))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 im (sqrt.f64 #s(literal -1 binary64))) (/.f64 im (.f64 re re)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 re)))) (fma.f64 (.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (log.f64 re)) #s(literal -1/16 binary64))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 re #s(literal 4 binary64))))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ 1 re)) (pow (sqrt -1) 2))))))) (* (log (/ 1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 re)))))) (* (sqrt (/ (log (/ 1 re)) (log 10))) (sqrt -1)))))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 im (sqrt.f64 #s(literal -1 binary64))) (/.f64 im (.f64 re re)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 re)))) (fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (log.f64 re)) #s(literal -1/16 binary64))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 re #s(literal 4 binary64)))) (.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/720 binary64) (.f64 (/.f64 (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (log.f64 re)) #s(literal -1/16 binary64))) (.f64 im im)) (log.f64 re)) #s(literal -1/4 binary64))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 10 binary64)))))))
(* -1 (/ (log (/ 1 re)) (log 10)))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(* -2 (log (/ 1 re)))
(neg.f64 (*.f64 #s(literal -2 binary64) (log.f64 re)))
(+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (/.f64 im re) (/.f64 im re) (neg.f64 (*.f64 #s(literal -2 binary64) (log.f64 re))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (neg.f64 (log.f64 re)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (* (pow (log 1/10) 2) (log (/ -1 re))))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 re)))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)) (.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) re) (/.f64 (*.f64 im im) re)) #s(literal 1/2 binary64)))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2)))))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) re) (/.f64 (.f64 im im) re)) #s(literal 1/2 binary64))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 re)))) (+ (* -1/4 (/ (* (pow im 4) (pow (log 1/10) 2)) (pow re 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow re 6))) (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))))))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)) (fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) re) (/.f64 (.f64 im im) re)) #s(literal 1/2 binary64)))))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (/ (log 1/10) (log (/ -1 re))))
(/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) re) (/.f64 (.f64 im im) re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(- (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3)))) (pow re 4)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(fma.f64 #s(literal -1 binary64) (+.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (.f64 (/.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/4 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))
(- (+ (* -1 (/ (log 1/10) (log (/ -1 re)))) (* -1 (/ (+ (* -1/8 (/ (* (pow im 6) (log 1/10)) (pow (log (/ -1 re)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow im 6)) (* 90 (pow im 6)))) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (* (pow im 4) (log 1/10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6)))) (+ (* -1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (* (pow im 4) (log 1/10)) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(-.f64 (-.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (.f64 (.f64 im im) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (.f64 (/.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) #s(literal 1/2 binary64) (.f64 (/.f64 (.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/720 binary64)))) (neg.f64 (pow.f64 re #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))))))
(* -1 (log (/ -1 re)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (*.f64 (/.f64 im re) (/.f64 im re)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))
(-.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 re #s(literal 6 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(/ (log (/ -1 re)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (fma.f64 (/.f64 #s(literal -1/6 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ -1 re))
(log.f64 (/.f64 #s(literal -1 binary64) re))
(+ (log (/ -1 re)) (* -1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/4 (/ (pow im 4) (pow re 4)))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/2 binary64) re) (/.f64 (.f64 im im) re) (log.f64 (/.f64 #s(literal -1 binary64) re))) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64))))
(+ (log (/ -1 re)) (+ (* -1/2 (/ (pow im 2) (pow re 2))) (+ (* -1/6 (/ (pow im 6) (pow re 6))) (* 1/4 (/ (pow im 4) (pow re 4))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/2 binary64) re) (/.f64 (.f64 im im) re) (log.f64 (/.f64 #s(literal -1 binary64) re))) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/6 binary64) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(* -2 (log (/ -1 re)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (*.f64 (/.f64 im re) (/.f64 im re)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))))
(pow re 2)
(*.f64 re re)
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))
(.f64 (fma.f64 (/.f64 im re) (/.f64 im re) #s(literal 1 binary64)) (.f64 re re))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 re #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(/ -1 (log (/ -1 re)))
(/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(- (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re))))
(fma.f64 (/.f64 (*.f64 (/.f64 im re) (/.f64 im re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(- (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (neg.f64 (pow.f64 re #s(literal 4 binary64)))) (fma.f64 (/.f64 (.f64 (/.f64 im re) (/.f64 im re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (+ (* 1/6 (/ (pow im 6) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (/ 1 (log (/ -1 re)))))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (.f64 (.f64 im im) (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))))) (neg.f64 (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 im re) (/.f64 im re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re)))))))
(* -1 (/ (log 10) (log (/ -1 re))))
(/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))
(+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) re) (/.f64 (.f64 im im) re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2))))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/8 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -2 binary64) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) re) (/.f64 (*.f64 im im) re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3)))) (pow re 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 3))) (+ (* 1/12 (/ (* (pow im 6) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/2 (/ (* (pow im 2) (+ (* -1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 2))) (* 1/8 (/ (* (pow im 4) (log 10)) (pow (log (/ -1 re)) 3))))) (log (/ -1 re)))))) (pow re 6))) (+ (* -1 (/ (log 10) (log (/ -1 re)))) (* -1/2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (/ -1 re)) 2)))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (fma.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/8 binary64))) (pow.f64 re #s(literal 4 binary64))) (/.f64 (fma.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal -1/16 binary64) (fma.f64 (.f64 (.f64 im im) (/.f64 (fma.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/8 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) #s(literal 1/2 binary64) (.f64 (/.f64 (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal 1/12 binary64)))) (pow.f64 re #s(literal 6 binary64)))) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) re) (/.f64 (*.f64 im im) re)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64)))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 im (sqrt.f64 #s(literal -1 binary64))) (/.f64 im (.f64 re re)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (.f64 (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1))))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 im (sqrt.f64 #s(literal -1 binary64))) (/.f64 im (.f64 re re)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 (.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))) #s(literal -1/16 binary64))) (sqrt.f64 #s(literal -1 binary64))) (/.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1/2 binary64) (.f64 (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64)))))
(+ (* 1/4 (* (/ (pow im 2) (* (pow re 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 re))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2)))))) (* (pow re 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (log 10))) (* 1/4 (/ (* (pow im 2) (- (* -1/4 (/ (pow im 4) (log 10))) (* 1/16 (/ (pow im 4) (* (log 10) (* (log (/ -1 re)) (pow (sqrt -1) 2))))))) (* (log (/ -1 re)) (pow (sqrt -1) 2))))) (* (pow re 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 re)))))) (* (sqrt (/ (log (/ -1 re)) (log 10))) (sqrt -1)))))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 im (sqrt.f64 #s(literal -1 binary64))) (/.f64 im (.f64 re re)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) re)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))) #s(literal -1/16 binary64))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 re #s(literal 4 binary64)))) (.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/720 binary64) (.f64 (.f64 (.f64 im im) (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))) #s(literal -1/16 binary64))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re))))) #s(literal -1/4 binary64))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (*.f64 (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64)))))
(* -1 (/ (log (/ -1 re)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 re #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* -2 (log (/ -1 re)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (*.f64 (/.f64 im re) (/.f64 im re)))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (+ (* 1/3 (/ (pow im 6) (pow re 6))) (/ (pow im 2) (pow re 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 im #s(literal 6 binary64))) (pow.f64 re #s(literal 6 binary64))))))
(* -1 (/ (log re) (log 1/10)))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(* (pow (log 1/10) 2) (log re))
(*.f64 (log.f64 re) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(+ (* 1/2 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 2))) (* (pow (log 1/10) 2) (log re)))
(fma.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) re) (/.f64 (.f64 im im) re)) #s(literal 1/2 binary64) (*.f64 (log.f64 re) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 4))) (* 1/2 (/ (pow (log 1/10) 2) (pow re 2))))) (* (pow (log 1/10) 2) (log re)))
(fma.f64 (fma.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (.f64 re re)) #s(literal 1/2 binary64) (.f64 (/.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (.f64 im im)) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64))) (.f64 im im) (.f64 (log.f64 re) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(+ (* (pow im 2) (+ (* 1/2 (/ (pow (log 1/10) 2) (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow (log 1/10) 2) (pow re 4))) (* 1/6 (/ (* (pow im 2) (pow (log 1/10) 2)) (pow re 6))))))) (* (pow (log 1/10) 2) (log re)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (.f64 im im)) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) re))) (.f64 im im) (*.f64 (log.f64 re) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(* -1 (/ (log re) (log 1/10)))
(/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1 (/ (log re) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1 (/ (log re) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal 1/10 binary64))))
(/ (log 1/10) (log re))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re))
(+ (* -1/2 (/ (* (pow im 2) (log 1/10)) (* (pow re 2) (pow (log re) 2)))) (/ (log 1/10) (log re)))
(fma.f64 (.f64 (/.f64 (.f64 im im) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (*.f64 re re))) #s(literal -1/2 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re)))
(+ (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 1/10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 1/10) (log re)))
(fma.f64 (fma.f64 (.f64 #s(literal 1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (.f64 im im) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) #s(literal -1/2 binary64))) (.f64 im im) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re)))
(+ (* (pow im 2) (- (* (pow im 2) (- (* -1 (* (pow im 2) (+ (* -1/2 (/ (+ (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 3))))) (* (pow re 2) (log re)))) (+ (* 1/8 (/ (log 1/10) (* (pow re 6) (pow (log re) 3)))) (* 1/6 (/ (log 1/10) (* (pow re 6) (pow (log re) 2)))))))) (+ (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 1/10) (* (pow re 4) (pow (log re) 3))))))) (* 1/2 (/ (log 1/10) (* (pow re 2) (pow (log re) 2)))))) (/ (log 1/10) (log re)))
(fma.f64 (fma.f64 (neg.f64 (fma.f64 (fma.f64 (/.f64 (.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))))) (.f64 (log.f64 re) (.f64 re re))) #s(literal -1/2 binary64) (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (/.f64 (.f64 #s(literal 1/8 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (.f64 im im) (.f64 #s(literal -1/4 binary64) (+.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64)))))))) (.f64 im im) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (.f64 re re))) #s(literal -1/2 binary64))) (.f64 im im) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 re)))
(log re)
(log.f64 re)
(+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) re) (/.f64 (*.f64 im im) re) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (log.f64 re))
(+ (log re) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/6 binary64) (/.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im) (log.f64 re))
(* -1/2 (/ (log (pow re 2)) (log 1/10)))
(.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))
(.f64 #s(literal -1/2 binary64) (fma.f64 (/.f64 im (log.f64 #s(literal 1/10 binary64))) (/.f64 im (.f64 re re)) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64)))
(+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 1/10 binary64))) #s(literal -1/2 binary64)))
(* -1/2 (log (pow re 2)))
(.f64 (log.f64 (.f64 re re)) #s(literal -1/2 binary64))
(+ (* -1/2 (log (pow re 2))) (* -1/2 (/ (pow im 2) (pow re 2))))
(.f64 #s(literal -1/2 binary64) (fma.f64 (/.f64 im re) (/.f64 im re) (log.f64 (.f64 re re))))
(+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/4 binary64) (/.f64 #s(literal -1/2 binary64) (.f64 re re))) (.f64 im im) (.f64 (log.f64 (*.f64 re re)) #s(literal -1/2 binary64)))
(+ (* -1/2 (log (pow re 2))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 re re))) (.f64 im im) (.f64 (log.f64 (.f64 re re)) #s(literal -1/2 binary64)))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(fma.f64 (/.f64 im re) (/.f64 im re) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (log.f64 (.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (log.f64 (*.f64 re re)))
(pow re 2)
(*.f64 re re)
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(+ (pow im 2) (pow re 2))
(fma.f64 re re (*.f64 im im))
(* 1/2 (/ (log (pow re 2)) (log 10)))
(.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))
(.f64 #s(literal 1/2 binary64) (fma.f64 (/.f64 im (.f64 re re)) (/.f64 im (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (*.f64 re re)) (log.f64 #s(literal 10 binary64)))))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re)))) (.f64 im im) (.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re)))) (.f64 im im) (.f64 (/.f64 (log.f64 (.f64 re re)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)))
(/ 2 (log (pow re 2)))
(/.f64 #s(literal 2 binary64) (log.f64 (*.f64 re re)))
(+ (* -2 (/ (pow im 2) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ 1 (log (pow re 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 im re) (/.f64 im re)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) #s(literal -2 binary64) (/.f64 #s(literal 2 binary64) (log.f64 (*.f64 re re))))
(+ (* (pow im 2) (- (* (pow im 2) (+ (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2))) (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(fma.f64 (fma.f64 (+.f64 (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64)))) (.f64 im im) (/.f64 #s(literal -2 binary64) (.f64 (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64)) (.f64 re re)))) (.f64 im im) (/.f64 #s(literal 2 binary64) (log.f64 (*.f64 re re))))
(+ (* (pow im 2) (- (* (pow im 2) (+ (* -1 (* (pow im 2) (+ (* 2/3 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 2)))) (+ (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 3)))) (* 2 (/ 1 (* (pow re 6) (pow (log (pow re 2)) 4)))))))) (+ (* 2 (/ 1 (* (pow re 4) (pow (log (pow re 2)) 3)))) (/ 1 (* (pow re 4) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (* (pow re 2) (pow (log (pow re 2)) 2)))))) (* 2 (/ 1 (log (pow re 2)))))
(fma.f64 (fma.f64 (fma.f64 (neg.f64 (.f64 im im)) (+.f64 (+.f64 (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 (log.f64 (.f64 re re)) #s(literal 4 binary64)) (pow.f64 re #s(literal 6 binary64)))) (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64))))) (/.f64 #s(literal 2/3 binary64) (.f64 (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64)) (pow.f64 re #s(literal 6 binary64))))) (+.f64 (/.f64 #s(literal 2 binary64) (.f64 (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64)) (pow.f64 re #s(literal 4 binary64)))) (/.f64 (/.f64 #s(literal 1 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))))) (.f64 im im) (/.f64 #s(literal -2 binary64) (.f64 (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64)) (.f64 re re)))) (.f64 im im) (/.f64 #s(literal 2 binary64) (log.f64 (.f64 re re))))
(* 2 (/ (log 10) (log (pow re 2))))
(/.f64 (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (.f64 re re)))
(+ (* -2 (/ (* (pow im 2) (log 10)) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* 2 (/ (log 10) (log (pow re 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) re) (/.f64 (.f64 im im) re)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) #s(literal -2 binary64) (/.f64 (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 re re))))
(+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))))) (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2)))))))
(fma.f64 (.f64 #s(literal -2 binary64) (fma.f64 (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64)))) (.f64 im im) (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))))) (.f64 im im) (/.f64 (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 re re))))
(+ (* 2 (/ (log 10) (log (pow re 2)))) (* (pow im 2) (+ (* -2 (/ (log 10) (* (pow re 2) (pow (log (pow re 2)) 2)))) (* (pow im 2) (+ (* -2 (* (pow im 2) (+ (* -1 (/ (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2))))) (* (pow re 2) (log (pow re 2))))) (+ (* 1/3 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 2)))) (* 1/2 (/ (log 10) (* (pow re 6) (pow (log (pow re 2)) 3)))))))) (* -2 (+ (* -1 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 3)))) (* -1/2 (/ (log 10) (* (pow re 4) (pow (log (pow re 2)) 2)))))))))))
(fma.f64 (fma.f64 (.f64 #s(literal -2 binary64) (fma.f64 (-.f64 (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64))) #s(literal 1/2 binary64) (.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) #s(literal 1/3 binary64))) (/.f64 (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64)))) (.f64 (log.f64 (.f64 re re)) (.f64 re re)))) (.f64 im im) (fma.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (log.f64 (.f64 re re)) #s(literal 3 binary64)))))) (.f64 im im) (.f64 (/.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re)) (pow.f64 (log.f64 (.f64 re re)) #s(literal 2 binary64))) #s(literal -2 binary64))) (.f64 im im) (/.f64 (.f64 #s(literal 2 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (*.f64 re re))))
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re)))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re)))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(sqrt (/ (log re) (log 10)))
(sqrt.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (sqrt (/ (log re) (log 10))) (* 1/4 (* (/ (pow im 2) (pow re 2)) (sqrt (/ 1 (* (log 10) (log re)))))))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 im re) (/.f64 im re))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 re))) (sqrt.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (sqrt (/ (log re) (log 10))) (* (pow im 2) (+ (* -1/2 (* (* (pow im 2) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (log re))))))) (sqrt (/ (log 10) (log re))))) (* 1/4 (* (/ 1 (pow re 2)) (sqrt (/ 1 (* (log 10) (log re)))))))))
(fma.f64 (fma.f64 (/.f64 (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 re))) (.f64 re re)) #s(literal 1/4 binary64) (.f64 (.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))) (.f64 (+.f64 (/.f64 #s(literal 1/16 binary64) (.f64 (.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 im im))) #s(literal -1/2 binary64))) (*.f64 im im) (sqrt.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(+ (sqrt (/ (log re) (log 10))) (* (pow im 2) (+ (* 1/4 (* (/ 1 (pow re 2)) (sqrt (/ 1 (* (log 10) (log re)))))) (* (pow im 2) (+ (* -1/2 (* (sqrt (/ (log 10) (log re))) (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (log re)))))))) (* 1/2 (* (* (pow im 2) (- (* 1/6 (/ 1 (* (pow re 6) (log 10)))) (* -1/4 (/ (+ (* 1/4 (/ 1 (* (pow re 4) (log 10)))) (* 1/16 (/ 1 (* (pow re 4) (* (log 10) (log re)))))) (* (pow re 2) (log re)))))) (sqrt (/ (log 10) (log re))))))))))
(fma.f64 (fma.f64 (fma.f64 (.f64 (.f64 im im) (.f64 (-.f64 (/.f64 #s(literal 1/6 binary64) (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64)))) (.f64 (/.f64 (+.f64 (/.f64 #s(literal 1/16 binary64) (.f64 (.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 (log.f64 re) (.f64 re re))) #s(literal -1/4 binary64))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))) #s(literal 1/2 binary64) (.f64 (.f64 #s(literal -1/2 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))) (+.f64 (/.f64 #s(literal 1/16 binary64) (.f64 (.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))) (pow.f64 re #s(literal 4 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))))) (.f64 im im) (.f64 (/.f64 (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 re))) (.f64 re re)) #s(literal 1/4 binary64))) (*.f64 im im) (sqrt.f64 (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
(/ (log re) (log 10))
(/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))
(+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re)))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))
(fma.f64 (fma.f64 (fma.f64 (/.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))) (/.f64 #s(literal -1/4 binary64) (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re)))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
(log (pow re 2))
(log.f64 (*.f64 re re))
(+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))
(fma.f64 (/.f64 im re) (/.f64 im re) (log.f64 (*.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))
(fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (log.f64 (.f64 re re)))
(+ (log (pow re 2)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/3 (/ (pow im 2) (pow re 6))) (* 1/2 (/ 1 (pow re 4))))) (/ 1 (pow re 2)))))
(fma.f64 (fma.f64 (fma.f64 (/.f64 (.f64 im im) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/3 binary64) (/.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64)))) (.f64 im im) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (log.f64 (*.f64 re re)))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (* (pow (log 1/10) 2) (log (/ 1 im))))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 im)))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))))
(fma.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) im) (/.f64 (.f64 re re) im)) #s(literal 1/2 binary64) (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im)))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2)))))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im) (fma.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) im) (/.f64 (.f64 re re) im)) #s(literal 1/2 binary64))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ 1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))))))
(fma.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (log.f64 im) (fma.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) im) (/.f64 (.f64 re re) im)) #s(literal 1/2 binary64)))))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/720 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (/ (log 1/10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im))
(+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (.f64 re re) im)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)))
(- (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(-.f64 (-.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1/4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (.f64 re re) im))))
(- (+ (* -1 (/ (log 1/10) (log (/ 1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 1/10)) (pow (log (/ 1 im)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(-.f64 (-.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 im)) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (.f64 (.f64 re re) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1/4 binary64))) (neg.f64 (log.f64 im)))) #s(literal 1/2 binary64) (.f64 (/.f64 (.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal 1/720 binary64)))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (.f64 re re) im)) (.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))))))
(* -1 (log (/ 1 im)))
(log.f64 im)
(+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(+.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (log.f64 im))
(+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(+.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))))) (log.f64 im))
(/ (log (/ 1 im)) (log 1/10))
(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal -1/6 binary64) (pow.f64 im #s(literal 6 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ 1 im))
(neg.f64 (log.f64 im))
(+ (log (/ 1 im)) (* -1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 (*.f64 re re) im) (neg.f64 (log.f64 im)))
(+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4)))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (log.f64 im))
(+ (log (/ 1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4))))))
(-.f64 (fma.f64 (.f64 (/.f64 re im) (/.f64 re im)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/6 binary64) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))) (log.f64 im))
(* -2 (log (/ 1 im)))
(*.f64 (neg.f64 (log.f64 im)) #s(literal -2 binary64))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 (neg.f64 (log.f64 im)) #s(literal -2 binary64)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 (neg.f64 (log.f64 im)) #s(literal -2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (neg.f64 (log.f64 im)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(/ -1 (log (/ 1 im)))
(/.f64 #s(literal 1 binary64) (log.f64 im))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 #s(literal 1 binary64) (log.f64 im)))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (neg.f64 (pow.f64 im #s(literal 4 binary64)))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (/ 1 (log (/ 1 im)))))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (.f64 re re)) (neg.f64 (log.f64 im))) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))))) (neg.f64 (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (fma.f64 (/.f64 #s(literal 1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im)))))))
(* -1 (/ (log 10) (log (/ 1 im))))
(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))
(+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (.f64 re re) im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2))))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1/8 binary64))) (pow.f64 im #s(literal 4 binary64))) #s(literal -2 binary64) (fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (*.f64 re re) im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ 1 im)) 3))))) (log (/ 1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ 1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ 1 im)) 2)))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1/8 binary64))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal -1/16 binary64) (fma.f64 (.f64 (.f64 re re) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1/8 binary64))) (neg.f64 (log.f64 im)))) #s(literal 1/2 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal 1/12 binary64)))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 #s(literal -1/2 binary64) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (*.f64 re re) im)) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64)))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 re (sqrt.f64 #s(literal -1 binary64))) (/.f64 re (.f64 im im)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 im)))) (.f64 (sqrt.f64 (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1))))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 re (sqrt.f64 #s(literal -1 binary64))) (/.f64 re (.f64 im im)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 im)))) (fma.f64 (.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #s(literal -1/16 binary64))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 im #s(literal 4 binary64))))) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (*.f64 (sqrt.f64 (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64)))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ 1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ 1 im)) (pow (sqrt -1) 2))))))) (* (log (/ 1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ 1 im)))))) (* (sqrt (/ (log (/ 1 im)) (log 10))) (sqrt -1)))))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 re (sqrt.f64 #s(literal -1 binary64))) (/.f64 re (.f64 im im)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 im)))) (fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (neg.f64 (log.f64 im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #s(literal -1/16 binary64))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 im #s(literal 4 binary64)))) (.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/720 binary64) (.f64 (/.f64 (.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (log.f64 im)) #s(literal -1/16 binary64))) (.f64 re re)) (log.f64 im)) #s(literal -1/4 binary64))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (*.f64 (sqrt.f64 (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64)))))
(* -1 (/ (log (/ 1 im)) (log 10)))
(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
(* -2 (log (/ 1 im)))
(*.f64 (neg.f64 (log.f64 im)) #s(literal -2 binary64))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 (neg.f64 (log.f64 im)) #s(literal -2 binary64)))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 (neg.f64 (log.f64 im)) #s(literal -2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (neg.f64 (log.f64 im)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (* (pow (log 1/10) 2) (log (/ -1 im))))
(*.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 im)))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)) (.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) im) (/.f64 (*.f64 re re) im)) #s(literal 1/2 binary64)))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2)))))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) im) (/.f64 (.f64 re re) im)) #s(literal 1/2 binary64))))
(+ (* -1 (* (pow (log 1/10) 2) (log (/ -1 im)))) (+ (* -1/4 (/ (* (pow re 4) (pow (log 1/10) 2)) (pow im 4))) (+ (* 1/720 (/ (* (pow (log 1/10) 2) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow im 6))) (* 1/2 (/ (* (pow re 2) (pow (log 1/10) 2)) (pow im 2))))))
(fma.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)) (fma.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (.f64 (.f64 (/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) im) (/.f64 (.f64 re re) im)) #s(literal 1/2 binary64)))))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal -1/720 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(* -1 (/ (log 1/10) (log (/ -1 im))))
(/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 1/10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(- (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3)))) (pow im 4)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(fma.f64 #s(literal -1 binary64) (+.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/4 binary64))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (.f64 (/.f64 #s(literal -1/2 binary64) (.f64 im im)) (/.f64 (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))))
(- (+ (* -1 (/ (log 1/10) (log (/ -1 im)))) (* -1 (/ (+ (* -1/8 (/ (* (pow re 6) (log 1/10)) (pow (log (/ -1 im)) 3))) (+ (* 1/720 (/ (* (log 1/10) (+ (* 30 (pow re 6)) (* 90 (pow re 6)))) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (* (pow re 4) (log 1/10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6)))) (+ (* -1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (* (pow re 4) (log 1/10)) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/2 (/ (* (pow re 2) (log 1/10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(-.f64 (-.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (.f64 (.f64 re re) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/4 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) #s(literal 1/2 binary64) (.f64 (/.f64 (.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/720 binary64)))) (neg.f64 (pow.f64 im #s(literal 6 binary64)))) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 (/.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) (fma.f64 (/.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 1/10 binary64))) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) im) (/.f64 (.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64)))))
(* -1 (log (/ -1 im)))
(neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (*.f64 (/.f64 re im) (/.f64 re im)) #s(literal 1/2 binary64) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))
(-.f64 (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))
(-.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (.f64 re re) im) (/.f64 (.f64 #s(literal 1/720 binary64) (*.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 im #s(literal 6 binary64))))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(/ (log (/ -1 im)) (log 1/10))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64)))))
(+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 #s(literal -1/6 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (fma.f64 (/.f64 #s(literal 1/4 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 1/10 binary64))))))
(log (/ -1 im))
(log.f64 (/.f64 #s(literal -1 binary64) im))
(+ (log (/ -1 im)) (* -1/2 (/ (pow re 2) (pow im 2))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 (*.f64 re re) im) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/4 (/ (pow re 4) (pow im 4)))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 (.f64 re re) im) (log.f64 (/.f64 #s(literal -1 binary64) im))) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64))))
(+ (log (/ -1 im)) (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/6 (/ (pow re 6) (pow im 6))) (* 1/4 (/ (pow re 4) (pow im 4))))))
(+.f64 (fma.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 (.f64 re re) im) (log.f64 (/.f64 #s(literal -1 binary64) im))) (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/6 binary64) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(* -2 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))))
(pow im 2)
(*.f64 im im)
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))
(.f64 (fma.f64 (/.f64 re im) (/.f64 re im) #s(literal 1 binary64)) (.f64 im im))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/6 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(/ -1 (log (/ -1 im)))
(/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(- (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im))))
(fma.f64 (/.f64 (*.f64 (/.f64 re im) (/.f64 re im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(- (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (neg.f64 (pow.f64 im #s(literal 4 binary64)))) (fma.f64 (/.f64 (.f64 (/.f64 re im) (/.f64 re im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(- (* -1 (/ (+ (* -1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (+ (* 1/6 (/ (pow re 6) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (/ 1 (log (/ -1 im)))))))
(-.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal -1/8 binary64) (fma.f64 (.f64 (.f64 re re) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) #s(literal 1/2 binary64) (/.f64 (.f64 #s(literal 1/6 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))))) (neg.f64 (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/4 binary64) (fma.f64 (/.f64 (*.f64 (/.f64 re im) (/.f64 re im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/2 binary64) (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im)))))))
(* -1 (/ (log 10) (log (/ -1 im))))
(/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))
(+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2))))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/8 binary64))) (pow.f64 im #s(literal 4 binary64))) #s(literal -2 binary64) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (*.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (* -2 (/ (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3)))) (pow im 4))) (+ (* -2 (/ (+ (* -1/16 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 3))) (+ (* 1/12 (/ (* (pow re 6) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/2 (/ (* (pow re 2) (+ (* -1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 2))) (* 1/8 (/ (* (pow re 4) (log 10)) (pow (log (/ -1 im)) 3))))) (log (/ -1 im)))))) (pow im 6))) (+ (* -1 (/ (log 10) (log (/ -1 im)))) (* -1/2 (/ (* (pow re 2) (log 10)) (* (pow im 2) (pow (log (/ -1 im)) 2)))))))
(fma.f64 #s(literal -2 binary64) (+.f64 (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/8 binary64))) (pow.f64 im #s(literal 4 binary64))) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal -1/16 binary64) (fma.f64 (.f64 (.f64 re re) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 3 binary64))) #s(literal 1/8 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/8 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) #s(literal 1/2 binary64) (.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) (log.f64 #s(literal 10 binary64))) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal 1/12 binary64)))) (pow.f64 im #s(literal 6 binary64)))) (fma.f64 (/.f64 (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 (*.f64 re re) im)) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal 2 binary64))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))
(*.f64 (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64)))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 re (sqrt.f64 #s(literal -1 binary64))) (/.f64 re (.f64 im im)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (.f64 (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1))))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 re (sqrt.f64 #s(literal -1 binary64))) (/.f64 re (.f64 im im)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 (.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))) #s(literal -1/16 binary64))) (sqrt.f64 #s(literal -1 binary64))) (/.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1/2 binary64) (.f64 (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64)))))
(+ (* 1/4 (* (/ (pow re 2) (* (pow im 2) (sqrt -1))) (sqrt (/ 1 (* (log 10) (log (/ -1 im))))))) (+ (* 1/2 (* (/ (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2)))))) (* (pow im 4) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (+ (* 1/2 (* (/ (- (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (log 10))) (* 1/4 (/ (* (pow re 2) (- (* -1/4 (/ (pow re 4) (log 10))) (* 1/16 (/ (pow re 4) (* (log 10) (* (log (/ -1 im)) (pow (sqrt -1) 2))))))) (* (log (/ -1 im)) (pow (sqrt -1) 2))))) (* (pow im 6) (sqrt -1))) (sqrt (/ (log 10) (log (/ -1 im)))))) (* (sqrt (/ (log (/ -1 im)) (log 10))) (sqrt -1)))))
(fma.f64 (.f64 #s(literal 1/4 binary64) (.f64 (/.f64 re (sqrt.f64 #s(literal -1 binary64))) (/.f64 re (.f64 im im)))) (sqrt.f64 (/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (/.f64 #s(literal -1 binary64) im)))) (fma.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))) #s(literal -1/16 binary64))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 im #s(literal 4 binary64)))) (.f64 #s(literal 1/2 binary64) (/.f64 (fma.f64 (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal 1/720 binary64) (.f64 (.f64 (.f64 re re) (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) #s(literal -1/4 binary64) (.f64 (/.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (log.f64 #s(literal 10 binary64))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)))) #s(literal -1/16 binary64))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) im))))) #s(literal -1/4 binary64))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (*.f64 (sqrt.f64 (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64)))) (sqrt.f64 #s(literal -1 binary64)))))
(* -1 (/ (log (/ -1 im)) (log 10)))
(/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (neg.f64 (log.f64 #s(literal 10 binary64)))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/4 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (fma.f64 (/.f64 #s(literal 1/720 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64)) (pow.f64 im #s(literal 6 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im))))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (log.f64 #s(literal 10 binary64))))
(* -2 (log (/ -1 im)))
(*.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64))
(+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (*.f64 (/.f64 re im) (/.f64 re im)))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal -1/2 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 im #s(literal 4 binary64)))))
(+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* 1/3 (/ (pow re 6) (pow im 6))) (/ (pow re 2) (pow im 2)))))
(fma.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) #s(literal -2 binary64) (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/2 binary64) (fma.f64 (/.f64 re im) (/.f64 re im) (/.f64 (*.f64 #s(literal 1/3 binary64) (pow.f64 re #s(literal 6 binary64))) (pow.f64 im #s(literal 6 binary64))))))

rewrite354.0ms (5%)

Memory

24.7MiB live, 252.3MiB allocated

Rules

3 876×	`lower-*.f32`
3 864×	`lower-*.f64`
3 200×	`lower-fma.f32`
3 196×	`lower-fma.f64`
2 452×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	42	218
0	66	232
1	189	227
2	908	195
3	6915	195
0	8055	144

Stop Event

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

Counts

20 → 1 223

Calls

Call 1

Inputs
(.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))
(log.f64 #s(literal 1/10 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
(log.f64 (fma.f64 re re (*.f64 im im)))
(fma.f64 re re (*.f64 im im))
(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))))
(/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (*.f64 re re)))))
(.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re))))))
(log.f64 #s(literal 10 binary64))
(pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))
(log.f64 (fma.f64 im im (*.f64 re re)))

Outputs
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval325.0ms (4.6%)

Memory: -13.4MiB live, 414.8MiB allocated
Compiler: Compiled 38 718 to 4 960 computations (87.2% saved)

prune53.0ms (0.7%)

Memory

39.1MiB live, 158.4MiB allocated

Pruning

17 alts after pruning (10 fresh and 7 done)

	Pruned	Kept	Total
New	1 759	5	1 764
Fresh	0	5	5
Picked	2	3	5
Done	0	4	4
Total	1 761	17	1 778

Accuracy

100.0%

Counts

1 778 → 17

Alt Table

Click to see full alt table

Status	Accuracy	Program
	71.6%	(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
	71.4%	(pow.f64 (/.f64 (sqrt.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (sqrt.f64 (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
	71.6%	(pow.f64 (sqrt.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
	98.6%	(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	98.5%	(/.f64 (.f64 (neg.f64 (pow.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
✓	54.1%	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓	54.1%	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
	98.5%	(/.f64 (neg.f64 (pow.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #s(literal 2 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))))
✓	98.6%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓	98.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
✓	98.6%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	98.6%	(/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))))
	98.6%	(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) #s(approx (/ -2 (neg (log (+ ( im im) (* re re))))) (/.f64 #s(literal 1 binary64) (log.f64 im)))))
	54.1%	(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))))
✓	98.6%	(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
✓	99.1%	(.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
	72.1%	(sqrt.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -2 binary64)))

Compiler

Compiled 574 to 297 computations (48.3% saved)

regimes96.0ms (1.4%)

Memory

-9.0MiB live, 187.2MiB allocated

Counts

34 → 1

Calls

Call 1

Inputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) #s(approx (/ -2 (neg (log (+ ( im im) (* re re))))) (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(sqrt.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -2 binary64)))
(pow.f64 (sqrt.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (hypot.f64 im re))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) #s(approx (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(pow.f64 (/.f64 (sqrt.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (sqrt.f64 (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (pow.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1 binary64))))
(pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(/.f64 (neg.f64 (pow.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #s(literal 2 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))))
(/.f64 (.f64 (neg.f64 (pow.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))))
(.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))))
(.f64 (/.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 3 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (exp.f64 (neg.f64 (log.f64 (log.f64 (hypot.f64 re im)))))))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1/2 binary64))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (hypot.f64 im re)))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (hypot.f64 im re)))))

Outputs

(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))

Calls

8 calls:

14.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
14.0ms	im
13.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
11.0ms	(*.f64 re re)
10.0ms	re

Results

Accuracy	Segments	Branch
99.1%	1	`re`
99.1%	1	`im`
99.1%	1	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
99.1%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
99.1%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
99.1%	1	`(+.f64 (.f64 re re) (.f64 im im))`
99.1%	1	`(*.f64 re re)`
99.1%	1	`(*.f64 im im)`

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes131.0ms (1.8%)

Memory

-41.1MiB live, 139.7MiB allocated

Counts

27 → 1

Calls

Call 1

Inputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) #s(approx (/ -2 (neg (log (+ ( im im) (* re re))))) (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(sqrt.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -2 binary64)))
(pow.f64 (sqrt.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (hypot.f64 im re))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) #s(approx (neg (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(pow.f64 (/.f64 (sqrt.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (sqrt.f64 (log.f64 #s(literal 10 binary64)))) #s(literal 2 binary64))
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1/2 binary64)) (pow.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1 binary64))))
(pow.f64 (pow.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal 1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(/.f64 (neg.f64 (pow.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) #s(literal 2 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))))
(/.f64 (.f64 (neg.f64 (pow.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) #s(literal 2 binary64))) #s(literal -1 binary64)) (.f64 #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))))

Outputs
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))

Calls

8 calls:

46.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
30.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
12.0ms	(*.f64 im im)
10.0ms	re
8.0ms	im

Results

Accuracy	Segments	Branch
99.0%	1	`re`
99.0%	1	`im`
99.0%	1	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
99.0%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
99.0%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
99.0%	1	`(+.f64 (.f64 re re) (.f64 im im))`
99.0%	1	`(*.f64 re re)`
99.0%	1	`(*.f64 im im)`

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes41.0ms (0.6%)

Memory

11.8MiB live, 93.7MiB allocated

Accuracy

Total -29.1b remaining (-3468.6%)

Threshold costs -29.1b (-3468.6%)

Counts

14 → 1

Calls

Call 1

Inputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) #s(approx (/ -2 (neg (log (+ ( im im) (* re re))))) (/.f64 #s(literal 1 binary64) (log.f64 im)))))
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (fma.f64 im im (*.f64 re re)))))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64))))
(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (fma.f64 im im (.f64 re re)))))))
(/.f64 #s(literal 1 binary64) (.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1/2 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (fma.f64 re re (.f64 im im))))))

Outputs
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))

Calls

8 calls:

7.0ms	im
5.0ms	re
5.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
5.0ms	(*.f64 im im)
4.0ms	(+.f64 (.f64 re re) (.f64 im im))

Results

Accuracy	Segments	Branch
98.7%	1	`re`
98.7%	1	`im`
98.7%	1	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
98.7%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
98.7%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
98.7%	1	`(+.f64 (.f64 re re) (.f64 im im))`
98.7%	1	`(*.f64 re re)`
98.7%	1	`(*.f64 im im)`

Compiler

Compiled 44 to 38 computations (13.6% saved)

simplify24.0ms (0.3%)

Memory

-14.6MiB live, 63.2MiB allocated

Algorithm

1×	egg-herbie

Rules

22×	`-commutative-binary64-.f64`
16×	`neg-sub0-binary64--.f64-neg.f64`
16×	`+-commutative-binary64-+.f64`
16×	`neg-mul-1-binary64-*.f64-neg.f64`
16×	`sub-neg-binary64-neg.f64-+.f64--.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	25	46
1	37	46
2	51	46
3	68	46
4	78	46
5	84	46
6	86	46

Stop Event

1×

saturated

Calls

Call 1

Inputs

(*.f64 (*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))

(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))

(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))

Outputs
(.f64 (.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))))
(.f64 (neg.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -3 binary64))) (.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 2 binary64))))
(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (hypot.f64 im re)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))

soundness670.0ms (9.5%)

Memory

17.3MiB live, 529.3MiB allocated

Rules

14 804×	`lower-fma.f64`
14 804×	`lower-fma.f32`
4 802×	`lower-fma.f64`
4 802×	`lower-fma.f32`
4 746×	`lower-*.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	39	199
0	62	208
1	183	202
2	955	178
3	7151	178
0	8300	134
0	10	41
0	17	41
1	44	41
2	251	41
3	2046	41
0	8387	25
0	33	138
0	54	104
1	155	103
2	712	103
3	5847	103
0	8039	102
0	268	1676
1	730	1632
2	2203	1630
3	5799	1618
0	8392	1506

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×	iter limit
1×	node limit
1×	iter limit

Compiler

Compiled 92 to 73 computations (20.7% saved)

preprocess90.0ms (1.3%)

Memory: 5.7MiB live, 205.1MiB allocated
Compiler: Compiled 332 to 294 computations (11.4% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

Iter	Nodes	Cost
0	24	62
1	50	62
2	96	62
3	173	62
4	238	62
5	260	62
6	271	62
7	282	62
8	285	62
9	286	62
0	10	12
0	17	12
1	18	12
0	18	7

Iter	Nodes	Cost
0	33	180
0	54	151
1	75	150
2	106	148
3	159	148
4	273	148
5	349	148
6	406	148
7	451	148
8	466	148
9	472	148
0	472	147

Iter	Nodes	Cost
0	24	62
1	50	62
2	96	62
3	173	62
4	238	62
5	260	62
6	271	62
7	282	62
8	285	62
9	286	62
0	10	12
0	17	12
1	18	12
0	18	7

Iter	Nodes	Cost
0	33	180
0	54	151
1	75	150
2	106	148
3	159	148
4	273	148
5	349	148
6	406	148
7	451	148
8	466	148
9	472	148
0	472	147

start0.0ms (0%)

analyze69.0ms (1%)

sample998.0ms (14.1%)

explain144.0ms (2%)

preprocess21.0ms (0.3%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify9.0ms (0.1%)

localize33.0ms (0.5%)

series38.0ms (0.5%)

simplify198.0ms (2.8%)

rewrite160.0ms (2.3%)

eval71.0ms (1%)

prune32.0ms (0.4%)

simplify45.0ms (0.6%)

localize130.0ms (1.8%)

series131.0ms (1.8%)

simplify486.0ms (6.9%)

rewrite243.0ms (3.4%)

eval301.0ms (4.2%)

prune73.0ms (1%)

simplify132.0ms (1.9%)

localize148.0ms (2.1%)

series70.0ms (1%)

simplify277.0ms (3.9%)

rewrite218.0ms (3.1%)

eval463.0ms (6.5%)

prune94.0ms (1.3%)

simplify122.0ms (1.7%)

localize162.0ms (2.3%)

series65.0ms (0.9%)

simplify368.0ms (5.2%)

rewrite354.0ms (5%)

eval325.0ms (4.6%)

prune53.0ms (0.7%)

regimes96.0ms (1.4%)

regimes131.0ms (1.8%)

regimes41.0ms (0.6%)

simplify24.0ms (0.3%)

soundness670.0ms (9.5%)

preprocess90.0ms (1.3%)

end0.0ms (0%)

Profiling

Iter	Nodes	Cost
0	24	62
1	50	62
2	96	62
3	173	62
4	238	62
5	260	62
6	271	62
7	282	62
8	285	62
9	286	62
0	10	12
0	17	12
1	18	12
0	18	7

Iter	Nodes	Cost
0	33	180
0	54	151
1	75	150
2	106	148
3	159	148
4	273	148
5	349	148
6	406	148
7	451	148
8	466	148
9	472	148
0	472	147