Metrics for math.log10 on complex, real part

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze77.0ms (1.3%)

Memory

-1.8MiB live, 76.7MiB 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)

sample910.0ms (15.1%)

Memory

0.6MiB live, 1 423.2MiB allocated

Samples

666.0ms

8 256×

valid

Precisions

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

ival-log: 187.0ms (45.7% of total)

ival-hypot: 159.0ms (38.9% of total)

ival-div: 50.0ms (12.2% of total)

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

exact: 5.0ms (1.2% of total)

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

Bogosity

explain127.0ms (2.1%)

Memory

-7.6MiB live, 277.0MiB allocated

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
126	-	-	`(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	104	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	104
↳	`(*.f64 re re)`	overflow	68
↳	`(*.f64 im im)`	overflow	54
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	22	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	22
↳	`(*.f64 re re)`	underflow	62
↳	`(*.f64 im im)`	underflow	69

Confusion

	Predicted +	Predicted -
+	126	0
-	0	130

Precision

1.0

Recall

1.0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	126	0	0
-	0	0	130

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	130
1	126

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

50.0ms

512×

valid

Compiler

Compiled 110 to 34 computations (69.1% saved)

Precisions

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

ival-log: 13.0ms (38% of total)

ival-hypot: 8.0ms (23.4% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

preprocess21.0ms (0.3%)

Memory

2.4MiB live, 41.2MiB allocated

Algorithm

1×	egg-herbie

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.4MiB live, 0.4MiB allocated
Compiler: Compiled 0 to 2 computations (-∞% saved)

prune1.0ms (0%)

Memory

1.8MiB live, 1.8MiB allocated

Alt Table

Click to see full alt table

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

simplify3.0ms (0%)

Memory

6.1MiB live, 6.1MiB 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))

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)

localize34.0ms (0.6%)

Memory

-11.0MiB live, 70.3MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.0078125	(+.f64 (.f64 re re) (.f64 im im))
accuracy	0.5840225586106522	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
accuracy	29.2957857036141	(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: 17.0ms

ival-log: 7.0ms (40.6% of total)

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

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

ival-div: 1.0ms (5.8% of total)

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

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

exact: 0.0ms (0% of total)

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

series17.0ms (0.3%)

Memory

5.0MiB live, 44.3MiB 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
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	@	-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	@	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	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	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))

simplify170.0ms (2.8%)

Memory

19.1MiB live, 258.7MiB allocated

Algorithm

1×	egg-herbie

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)

rewrite142.0ms (2.3%)

Memory

13.1MiB live, 245.6MiB allocated

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>

eval59.0ms (1%)

Memory: -31.7MiB live, 128.3MiB allocated
Compiler: Compiled 10 557 to 1 829 computations (82.7% saved)

prune18.0ms (0.3%)

Memory

10.9MiB live, 50.5MiB allocated

Pruning

14 alts after pruning (14 fresh and 0 done)

	Pruned	Kept	Total
New	407	14	421
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	408	14	422

Accuracy

100.0%

Counts

422 → 14

Alt Table

Click to see full alt table

Status	Accuracy	Program
	69.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))
	70.5%	(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))
▶	98.6%	(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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))))
	51.8%	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
▶	99.1%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
	51.9%	(/.f64 (log.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 10 binary64)))
▶	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
	51.9%	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
▶	98.3%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
	98.9%	(/.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))))
	98.6%	(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (/.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))
▶	69.5%	(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)))

Compiler

Compiled 310 to 278 computations (10.3% saved)

simplify19.0ms (0.3%)

Memory

-8.9MiB live, 36.1MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))
cost-diff	0	(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))))
cost-diff	192	(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))
cost-diff	12928	(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)))
cost-diff	0	(pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))
cost-diff	0	(log.f64 #s(literal 10 binary64))
cost-diff	0	(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
cost-diff	12928	(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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)))
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	(log.f64 #s(literal 10 binary64))
cost-diff	0	(hypot.f64 re im)
cost-diff	0	(log.f64 (hypot.f64 re im))
cost-diff	0	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	29	150
0	48	142
1	63	141
2	81	141
3	100	141
4	128	141
5	178	141
6	263	141
7	371	141
8	414	141
9	432	141
10	446	141
11	459	141
12	468	141
13	476	141
14	480	141
0	480	141

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (hypot.f64 re im))
(hypot.f64 re im)
re
im
(log.f64 #s(literal 10 binary64))
#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)
(/.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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#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
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))
(log.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)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
im
re
#s(literal -1 binary64)

Outputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64)))
(log.f64 (hypot.f64 re im))
(log.f64 (hypot.f64 im re))
(hypot.f64 re im)
(hypot.f64 im re)
re
im
(log.f64 #s(literal 10 binary64))
#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)
(/.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))))
(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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64)))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#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
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)))
(/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))))
(log.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)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
im
re
#s(literal -1 binary64)

localize88.0ms (1.5%)

Memory

24.0MiB live, 180.4MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.03515625	(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re))))
accuracy	0.4716987793053261	(/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))
accuracy	0.7648393430525048	(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)))
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.19140625	(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
accuracy	0.20703125	(pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))
accuracy	0.70703125	(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
accuracy	0	(neg.f64 (log.f64 (hypot.f64 im re)))
accuracy	0	(log.f64 (hypot.f64 im re))
accuracy	0.4043350586106521	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
accuracy	0.70703125	(log.f64 #s(literal 1/10 binary64))
accuracy	0	(log.f64 im)
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.40284441697312884	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.4043350586106521	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
accuracy	0	(hypot.f64 re im)
accuracy	0	(log.f64 (hypot.f64 re im))
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.4043350586106521	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))

Samples

45.0ms	181×	0	valid
20.0ms	75×	0	invalid

Compiler

Compiled 241 to 24 computations (90% saved)

Precisions

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

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

ival-hypot: 8.0ms (17.1% of total)

ival-div: 7.0ms (14.9% of total)

ival-pow: 5.0ms (10.7% of total)

const: 4.0ms (8.5% of total)

ival-exp: 2.0ms (4.3% of total)

ival-mult: 2.0ms (4.3% of total)

ival-neg: 1.0ms (2.1% of total)

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

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

exact: 0.0ms (0% of total)

series128.0ms (2.1%)

Memory

-15.6MiB live, 256.6MiB allocated

Counts

19 → 372

Calls

Call 1

Inputs
#s(alt (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (log.f64 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<representation binary64>) () ())
#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 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 #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 (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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())
#s(alt (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (patch (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) #<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>) () ())
#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) #<representation binary64>) () ())
#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())
#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.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 (log.f64 #s(literal 1/10 binary64)) (patch (log.f64 #s(literal 1/10 binary64)) #<representation binary64>) () ())

Outputs
#s(alt (/ (log im) (log 10)) (taylor 0 re) (#s(alt (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt (log.f64 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (log.f64 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<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 (* -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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (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 10)))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<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 im) (log 10)) (taylor 0 re) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ (log 10) (log im)))) (taylor 0 re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ (log 10) (log im)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log im))))) (taylor 0 re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ (log 10) (log im)))) (* (pow re 2) (+ (* -1/24 (* (pow re 2) (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2))))))) (* 1/2 (/ 1 (* (pow im 2) (log im))))))) (taylor 0 re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ (log 10) (log im)))) (* (pow re 2) (+ (* (pow re 2) (+ (* -1/24 (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2)))))) (* -1/720 (* (pow re 2) (- (+ (* -720 (/ (* (log im) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow im 6) (pow (log im) 3))))))))) (* 1/2 (/ 1 (* (pow im 2) (log im))))))) (taylor 0 re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (log (/ (log 10) (log im))) (taylor 0 re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ (log 10) (log im))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log im))))) (taylor 0 re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ (log 10) (log im))) (* (pow re 2) (- (* 1/24 (* (pow re 2) (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2))))))) (* 1/2 (/ 1 (* (pow im 2) (log im))))))) (taylor 0 re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ (log 10) (log im))) (* (pow re 2) (- (* (pow re 2) (+ (* 1/720 (* (pow re 2) (- (+ (* -720 (/ (* (log im) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow im 6) (pow (log im) 3))))))) (* 1/24 (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2)))))))) (* 1/2 (/ 1 (* (pow im 2) (log im))))))) (taylor 0 re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.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 (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<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 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<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 (/ (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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (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 (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 (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (taylor inf re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re)))))) (taylor inf re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))) (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4))))) (taylor inf re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 720 (/ (* (log (/ 1 re)) (+ (* -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))))))) (log 10))))) (pow re 6)))))) (taylor inf re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (log (* -1 (/ (log 10) (log (/ 1 re))))) (taylor inf re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re)))))) (taylor inf re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))) (taylor inf re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 720 (/ (* (log (/ 1 re)) (+ (* -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))))))) (log 10))))) (pow re 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re)))))))) (taylor inf re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.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 (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<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 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<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 (/ (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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (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 (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 (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (taylor -inf re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re)))))) (taylor -inf re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))) (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4))))) (taylor -inf re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 720 (/ (* (log (/ -1 re)) (+ (* -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))))))) (log 10))))) (pow re 6)))))) (taylor -inf re) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (log (* -1 (/ (log 10) (log (/ -1 re))))) (taylor -inf re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re)))))) (taylor -inf re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))) (taylor -inf re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 720 (/ (* (log (/ -1 re)) (+ (* -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))))))) (log 10))))) (pow re 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re)))))))) (taylor -inf re) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.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 re) (log 10)) (taylor 0 im) (#s(alt (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt (log.f64 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<representation binary64>) () ())) ())
#s(alt (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor 0 im) (#s(alt (log.f64 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<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 (* -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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (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 10)))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<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 re) (log 10)) (taylor 0 im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ (log 10) (log re)))) (taylor 0 im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ (log 10) (log re)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log re))))) (taylor 0 im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ (log 10) (log re)))) (* (pow im 2) (+ (* -1/24 (* (pow im 2) (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2))))))) (* 1/2 (/ 1 (* (pow re 2) (log re))))))) (taylor 0 im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ (log 10) (log re)))) (* (pow im 2) (+ (* (pow im 2) (+ (* -1/24 (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2)))))) (* -1/720 (* (pow im 2) (- (+ (* -720 (/ (* (log re) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow re 6) (pow (log re) 3))))))))) (* 1/2 (/ 1 (* (pow re 2) (log re))))))) (taylor 0 im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (log (/ (log 10) (log re))) (taylor 0 im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ (log 10) (log re))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log re))))) (taylor 0 im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ (log 10) (log re))) (* (pow im 2) (- (* 1/24 (* (pow im 2) (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2))))))) (* 1/2 (/ 1 (* (pow re 2) (log re))))))) (taylor 0 im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (/ (log 10) (log re))) (* (pow im 2) (- (* (pow im 2) (+ (* 1/720 (* (pow im 2) (- (+ (* -720 (/ (* (log re) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow re 6) (pow (log re) 3))))))) (* 1/24 (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2)))))))) (* 1/2 (/ 1 (* (pow re 2) (log re))))))) (taylor 0 im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.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 (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (log.f64 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<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 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<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 (/ (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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (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 (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 (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (taylor inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im)))))) (taylor inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))) (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4))))) (taylor inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 720 (/ (* (log (/ 1 im)) (+ (* -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))))))) (log 10))))) (pow im 6)))))) (taylor inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (log (* -1 (/ (log 10) (log (/ 1 im))))) (taylor inf im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im)))))) (taylor inf im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))) (taylor inf im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 720 (/ (* (log (/ 1 im)) (+ (* -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))))))) (log 10))))) (pow im 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im)))))))) (taylor inf im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.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 (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt (log.f64 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<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 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re 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 (hypot.f64 re im)) (patch (log.f64 (hypot.f64 re im)) #<representation binary64>) () ())) ())
#s(alt (* -1 im) (taylor -inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re im) #<representation binary64>) () ())) ())
#s(alt (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor -inf im) (#s(alt (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re 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 (hypot.f64 re im) (patch (hypot.f64 re im) #<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 (/ (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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (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 (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 (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 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 (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) (patch (exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im)))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))) (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 720 (/ (* (log (/ -1 im)) (+ (* -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))))))) (log 10))))) (pow im 6)))))) (taylor -inf im) (#s(alt (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (patch (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) #<representation binary64>) () ())) ())
#s(alt (log (* -1 (/ (log 10) (log (/ -1 im))))) (taylor -inf im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im)))))) (taylor -inf im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))) (taylor -inf im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 720 (/ (* (log (/ -1 im)) (+ (* -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))))))) (log 10))))) (pow im 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im)))))))) (taylor -inf im) (#s(alt (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) (patch (log.f64 (/.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>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
38.0ms	im	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (log 10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (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))) (/ (pow (log 10) -1) (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (log 10) -1) (pow (log (sqrt (+ (* im im) (* re re)))) -1) (exp (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1)) (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1) (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (log 1/10))
33.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (log 10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (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))) (/ (pow (log 10) -1) (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (log 10) -1) (pow (log (sqrt (+ (* im im) (* re re)))) -1) (exp (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1)) (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1) (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (log 1/10))
18.0ms	im	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (log 10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (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))) (/ (pow (log 10) -1) (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (log 10) -1) (pow (log (sqrt (+ (* im im) (* re re)))) -1) (exp (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1)) (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1) (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (log 1/10))
9.0ms	re	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (log 10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (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))) (/ (pow (log 10) -1) (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (log 10) -1) (pow (log (sqrt (+ (* im im) (* re re)))) -1) (exp (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1)) (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1) (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (log 1/10))
7.0ms	re	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (log 10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ (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))) (/ (pow (log 10) -1) (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (log 10) -1) (pow (log (sqrt (+ (* im im) (* re re)))) -1) (exp (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1)) (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1) (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) (/ (log 10) (log (sqrt (+ (* im im) (* re re))))) (log 1/10))

simplify214.0ms (3.6%)

Memory

13.2MiB live, 370.6MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1064	12258
1	3243	11900
0	8927	11346

Stop Event

1×	iter limit
1×	node limit

Counts

372 → 364

Calls

Call 1

Inputs
(/ (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))))))
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))))))
(* -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)))
(/ 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 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)))
(* -1 (log (/ (log 10) (log im))))
(+ (* -1 (log (/ (log 10) (log im)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log im)))))
(+ (* -1 (log (/ (log 10) (log im)))) (* (pow re 2) (+ (* -1/24 (* (pow re 2) (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2))))))) (* 1/2 (/ 1 (* (pow im 2) (log im)))))))
(+ (* -1 (log (/ (log 10) (log im)))) (* (pow re 2) (+ (* (pow re 2) (+ (* -1/24 (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2)))))) (* -1/720 (* (pow re 2) (- (+ (* -720 (/ (* (log im) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow im 6) (pow (log im) 3))))))))) (* 1/2 (/ 1 (* (pow im 2) (log im)))))))
(log (/ (log 10) (log im)))
(+ (log (/ (log 10) (log im))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log im)))))
(+ (log (/ (log 10) (log im))) (* (pow re 2) (- (* 1/24 (* (pow re 2) (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2))))))) (* 1/2 (/ 1 (* (pow im 2) (log im)))))))
(+ (log (/ (log 10) (log im))) (* (pow re 2) (- (* (pow re 2) (+ (* 1/720 (* (pow re 2) (- (+ (* -720 (/ (* (log im) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow im 6) (pow (log im) 3))))))) (* 1/24 (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2)))))))) (* 1/2 (/ 1 (* (pow im 2) (log im)))))))
(/ (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 (/ 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))))))
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))))))
(/ (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/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 (/ 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 (/ (log 10) (log (/ 1 re))))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))) (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4)))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 720 (/ (* (log (/ 1 re)) (+ (* -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))))))) (log 10))))) (pow re 6))))))
(log (* -1 (/ (log 10) (log (/ 1 re)))))
(+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))
(+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re)))))))
(+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 720 (/ (* (log (/ 1 re)) (+ (* -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))))))) (log 10))))) (pow re 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (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)))))
(- (+ (* -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/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))))))
(* -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))))))
(/ (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/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 (/ -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 (/ (log 10) (log (/ -1 re))))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))) (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4)))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 720 (/ (* (log (/ -1 re)) (+ (* -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))))))) (log 10))))) (pow re 6))))))
(log (* -1 (/ (log 10) (log (/ -1 re)))))
(+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))
(+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re)))))))
(+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 720 (/ (* (log (/ -1 re)) (+ (* -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))))))) (log 10))))) (pow re 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (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)))))
(- (+ (* -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 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)))))
(/ (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)
(* -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)))
(/ 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 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)))
(* -1 (log (/ (log 10) (log re))))
(+ (* -1 (log (/ (log 10) (log re)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log re)))))
(+ (* -1 (log (/ (log 10) (log re)))) (* (pow im 2) (+ (* -1/24 (* (pow im 2) (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2))))))) (* 1/2 (/ 1 (* (pow re 2) (log re)))))))
(+ (* -1 (log (/ (log 10) (log re)))) (* (pow im 2) (+ (* (pow im 2) (+ (* -1/24 (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2)))))) (* -1/720 (* (pow im 2) (- (+ (* -720 (/ (* (log re) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow re 6) (pow (log re) 3))))))))) (* 1/2 (/ 1 (* (pow re 2) (log re)))))))
(log (/ (log 10) (log re)))
(+ (log (/ (log 10) (log re))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log re)))))
(+ (log (/ (log 10) (log re))) (* (pow im 2) (- (* 1/24 (* (pow im 2) (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2))))))) (* 1/2 (/ 1 (* (pow re 2) (log re)))))))
(+ (log (/ (log 10) (log re))) (* (pow im 2) (- (* (pow im 2) (+ (* 1/720 (* (pow im 2) (- (+ (* -720 (/ (* (log re) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow re 6) (pow (log re) 3))))))) (* 1/24 (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2)))))))) (* 1/2 (/ 1 (* (pow re 2) (log re)))))))
(/ (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 (/ 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)))))))
(* -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)))
(/ (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/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)))))))
(* -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 (/ (log 10) (log (/ 1 im))))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))) (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4)))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 720 (/ (* (log (/ 1 im)) (+ (* -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))))))) (log 10))))) (pow im 6))))))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))
(+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im)))))))
(+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 720 (/ (* (log (/ 1 im)) (+ (* -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))))))) (log 10))))) (pow im 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (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)))))
(- (+ (* -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/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))))))))
(* -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))))
(/ (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/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)))))))
(* -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 (/ (log 10) (log (/ -1 im))))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))) (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4)))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 720 (/ (* (log (/ -1 im)) (+ (* -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))))))) (log 10))))) (pow im 6))))))
(log (* -1 (/ (log 10) (log (/ -1 im)))))
(+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))
(+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im)))))))
(+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 720 (/ (* (log (/ -1 im)) (+ (* -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))))))) (log 10))))) (pow im 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (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)))))
(- (+ (* -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)))))))

Outputs
(/ (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 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 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 (/.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))
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 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 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 (/.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) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 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 #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))
(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))
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 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 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))))
(/ 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 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 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 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))))
(* -1 (log (/ (log 10) (log im))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(+ (* -1 (log (/ (log 10) (log im)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log im)))))
(-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 im)) (.f64 (/.f64 re im) (/.f64 re im))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(+ (* -1 (log (/ (log 10) (log im)))) (* (pow re 2) (+ (* -1/24 (* (pow re 2) (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2))))))) (* 1/2 (/ 1 (* (pow im 2) (log im)))))))
(fma.f64 (fma.f64 (.f64 (.f64 re re) #s(literal -1/24 binary64)) (fma.f64 (/.f64 (.f64 (.f64 (log.f64 im) #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)))))) (log.f64 #s(literal 10 binary64))) #s(literal -24 binary64) (/.f64 #s(literal -3 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 (log.f64 im) im) im))) (*.f64 re re) (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(+ (* -1 (log (/ (log 10) (log im)))) (* (pow re 2) (+ (* (pow re 2) (+ (* -1/24 (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2)))))) (* -1/720 (* (pow re 2) (- (+ (* -720 (/ (* (log im) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow im 6) (pow (log im) 3))))))))) (* 1/2 (/ 1 (* (pow im 2) (log im)))))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal -1/720 binary64) (.f64 re re)) (fma.f64 (/.f64 (.f64 (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)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal -720 binary64) (-.f64 (/.f64 (.f64 #s(literal 90 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 #s(literal 10 binary64)) im) im)) (/.f64 #s(literal 30 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (.f64 (fma.f64 (/.f64 (.f64 (.f64 (log.f64 im) #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)))))) (log.f64 #s(literal 10 binary64))) #s(literal -24 binary64) (/.f64 #s(literal -3 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))))) #s(literal -1/24 binary64))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 im) im) im))) (*.f64 re re) (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(log (/ (log 10) (log im)))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+ (log (/ (log 10) (log im))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log im)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 im)) (*.f64 (/.f64 re im) (/.f64 re im)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(+ (log (/ (log 10) (log im))) (* (pow re 2) (- (* 1/24 (* (pow re 2) (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2))))))) (* 1/2 (/ 1 (* (pow im 2) (log im)))))))
(fma.f64 (fma.f64 (.f64 (.f64 re re) #s(literal 1/24 binary64)) (fma.f64 (/.f64 (.f64 (.f64 (log.f64 im) #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)))))) (log.f64 #s(literal 10 binary64))) #s(literal -24 binary64) (/.f64 #s(literal -3 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 (log.f64 im) im) im))) (*.f64 re re) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(+ (log (/ (log 10) (log im))) (* (pow re 2) (- (* (pow re 2) (+ (* 1/720 (* (pow re 2) (- (+ (* -720 (/ (* (log im) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow im 6) (pow (log im) 3))))))) (* 1/24 (- (* -24 (/ (* (log im) (+ (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 2)))) (* -1/4 (/ (log 10) (* (pow im 4) (pow (log im) 3)))))) (log 10))) (* 3 (/ 1 (* (pow im 4) (pow (log im) 2)))))))) (* 1/2 (/ 1 (* (pow im 2) (log im)))))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/720 binary64) (.f64 re re)) (fma.f64 (/.f64 (.f64 (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)))) (log.f64 im)) (log.f64 #s(literal 10 binary64))) #s(literal -720 binary64) (-.f64 (/.f64 (.f64 #s(literal 90 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 #s(literal 10 binary64)) im) im)) (/.f64 #s(literal 30 binary64) (.f64 (pow.f64 (log.f64 im) #s(literal 3 binary64)) (pow.f64 im #s(literal 6 binary64)))))) (.f64 #s(literal 1/24 binary64) (fma.f64 (/.f64 (.f64 (.f64 (log.f64 im) #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)))))) (log.f64 #s(literal 10 binary64))) #s(literal -24 binary64) (/.f64 #s(literal -3 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 (log.f64 im) im) im))) (*.f64 re re) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(/ (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 (/ 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) (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 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/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) (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) (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 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/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.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) (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) (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 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)))
(/.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))) (neg.f64 (/.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))) (neg.f64 (/.f64 #s(literal 1 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) (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 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 (/ (log 10) (log (/ 1 re))))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))
(-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (.f64 (neg.f64 (log.f64 re)) (.f64 re re))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))) (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4)))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 24 binary64) (neg.f64 (log.f64 re))) (/.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))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal -3 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/24 binary64) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (.f64 (neg.f64 (log.f64 re)) (*.f64 re re))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 720 (/ (* (log (/ 1 re)) (+ (* -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))))))) (log 10))))) (pow re 6))))))
(-.f64 (fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 720 binary64) (neg.f64 (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))))))) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) #s(literal 30 binary64) (.f64 (.f64 #s(literal -360 binary64) (.f64 im im)) (/.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))))) (log.f64 #s(literal 10 binary64)))))) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 24 binary64) (neg.f64 (log.f64 re))) (/.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))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal -3 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/24 binary64) (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (.f64 (neg.f64 (log.f64 re)) (*.f64 re re))))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(log (* -1 (/ (log 10) (log (/ 1 re)))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (neg.f64 (log.f64 re))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re)))))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 24 binary64) (neg.f64 (log.f64 re))) (/.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))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal -3 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/24 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (*.f64 im im) (neg.f64 (log.f64 re))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))))
(+ (log (* -1 (/ (log 10) (log (/ 1 re))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 720 (/ (* (log (/ 1 re)) (+ (* -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))))))) (log 10))))) (pow re 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ 1 re)) 2))) (* 24 (/ (* (log (/ 1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ 1 re))))))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 720 binary64) (neg.f64 (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))))))) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (pow.f64 im #s(literal 6 binary64)) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)))) #s(literal 30 binary64) (.f64 (.f64 #s(literal -360 binary64) (.f64 im im)) (/.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))))) (log.f64 #s(literal 10 binary64)))))) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 24 binary64) (neg.f64 (log.f64 re))) (/.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))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal -3 binary64) (pow.f64 im #s(literal 4 binary64))) (pow.f64 (log.f64 re) #s(literal 2 binary64)))) (pow.f64 re #s(literal 4 binary64))) #s(literal 1/24 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (*.f64 im im) (neg.f64 (log.f64 re))) (log.f64 (/.f64 (log.f64 #s(literal 10 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 #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)))))))
(* -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) (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 (/.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) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 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 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 (log.f64 #s(literal 10 binary64)) re) re)))) (/.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 (/.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)))
(* -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) (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 (/.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) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 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 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 (log.f64 #s(literal 10 binary64)) re) re)))) (/.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 (/.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/4 binary64) (log.f64 #s(literal 1/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 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/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/4 binary64) (log.f64 #s(literal 1/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 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))))))
(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 (/.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)))
(* -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) (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 (/.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) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 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 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 (log.f64 #s(literal 10 binary64)) re) 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/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 (/ -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) (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 (/.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) (pow.f64 re #s(literal 6 binary64))) (/.f64 (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 binary64)) (log.f64 #s(literal 10 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 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 (log.f64 #s(literal 10 binary64)) re) re)))) (/.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (log.f64 #s(literal 10 binary64))))
(* -1 (log (* -1 (/ (log 10) (log (/ -1 re))))))
(neg.f64 (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))
(-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (.f64 re re))) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))) (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4)))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (fma.f64 (/.f64 (.f64 (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 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))) (log.f64 #s(literal 10 binary64))) #s(literal 24 binary64) (/.f64 (.f64 #s(literal -3 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/24 binary64) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 re re))) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 re)))))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 720 (/ (* (log (/ -1 re)) (+ (* -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))))))) (log 10))))) (pow re 6))))))
(-.f64 (fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 720 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (/.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 10 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))))) (log.f64 #s(literal 10 binary64))) (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 30 binary64) (.f64 (.f64 #s(literal -360 binary64) (.f64 im im)) (/.f64 (fma.f64 (/.f64 (.f64 (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 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 #s(literal 10 binary64)))))) (pow.f64 re #s(literal 6 binary64))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (fma.f64 (/.f64 (.f64 (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 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))) (log.f64 #s(literal 10 binary64))) #s(literal 24 binary64) (/.f64 (.f64 #s(literal -3 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/24 binary64) (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) (*.f64 re re))))) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(log (* -1 (/ (log 10) (log (/ -1 re)))))
(log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))))
(+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re)))))
(+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re)))))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (fma.f64 (/.f64 (.f64 (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 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))) (log.f64 #s(literal 10 binary64))) #s(literal 24 binary64) (/.f64 (.f64 #s(literal -3 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/24 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) re))))))
(+ (log (* -1 (/ (log 10) (log (/ -1 re))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 720 (/ (* (log (/ -1 re)) (+ (* -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))))))) (log 10))))) (pow re 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow im 4) (pow (log (/ -1 re)) 2))) (* 24 (/ (* (log (/ -1 re)) (+ (* -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 10)))) (pow re 4))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log (/ -1 re))))))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 720 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (/.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 10 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))))) (log.f64 #s(literal 10 binary64))) (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 30 binary64) (.f64 (.f64 #s(literal -360 binary64) (.f64 im im)) (/.f64 (fma.f64 (/.f64 (.f64 (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 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 #s(literal 10 binary64)))))) (pow.f64 re #s(literal 6 binary64))) #s(literal 1/720 binary64) (fma.f64 (/.f64 (fma.f64 (/.f64 (.f64 (fma.f64 (/.f64 (.f64 (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 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))) (log.f64 #s(literal 10 binary64))) #s(literal 24 binary64) (/.f64 (.f64 #s(literal -3 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/24 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) (.f64 re re)) (/.f64 (*.f64 im im) (log.f64 (/.f64 #s(literal -1 binary64) re))) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 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))))
(- (+ (* -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 (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 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 (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 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 (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))) (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 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 (log.f64 #s(literal 10 binary64)) im) im) (pow.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)) #s(literal 2 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 (.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))
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) (log.f64 #s(literal 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 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)
(* -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) (log.f64 #s(literal 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 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))))
(/ 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 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 (.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))))
(* -1 (log (/ (log 10) (log re))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(+ (* -1 (log (/ (log 10) (log re)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log re)))))
(-.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 re)) (.f64 (/.f64 im re) (/.f64 im re))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(+ (* -1 (log (/ (log 10) (log re)))) (* (pow im 2) (+ (* -1/24 (* (pow im 2) (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2))))))) (* 1/2 (/ 1 (* (pow re 2) (log re)))))))
(fma.f64 (fma.f64 (.f64 (.f64 im im) #s(literal -1/24 binary64)) (fma.f64 (/.f64 (.f64 (.f64 (log.f64 re) #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)))))) (log.f64 #s(literal 10 binary64))) #s(literal -24 binary64) (/.f64 #s(literal -3 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 (.f64 (log.f64 re) re) re))) (.f64 im im) (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))))
(+ (* -1 (log (/ (log 10) (log re)))) (* (pow im 2) (+ (* (pow im 2) (+ (* -1/24 (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2)))))) (* -1/720 (* (pow im 2) (- (+ (* -720 (/ (* (log re) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow re 6) (pow (log re) 3))))))))) (* 1/2 (/ 1 (* (pow re 2) (log re)))))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal -1/720 binary64) (.f64 im im)) (fma.f64 (/.f64 (.f64 (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)))) (log.f64 re)) (log.f64 #s(literal 10 binary64))) #s(literal -720 binary64) (-.f64 (/.f64 (.f64 #s(literal 90 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 #s(literal 10 binary64)) re) re)) (/.f64 #s(literal 30 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (.f64 (fma.f64 (/.f64 (.f64 (.f64 (log.f64 re) #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)))))) (log.f64 #s(literal 10 binary64))) #s(literal -24 binary64) (/.f64 #s(literal -3 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))) #s(literal -1/24 binary64))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (log.f64 re) re) re))) (.f64 im im) (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))))
(log (/ (log 10) (log re)))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re)))
(+ (log (/ (log 10) (log re))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log re)))))
(fma.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 re)) (*.f64 (/.f64 im re) (/.f64 im re)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(+ (log (/ (log 10) (log re))) (* (pow im 2) (- (* 1/24 (* (pow im 2) (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2))))))) (* 1/2 (/ 1 (* (pow re 2) (log re)))))))
(fma.f64 (fma.f64 (.f64 (.f64 im im) #s(literal 1/24 binary64)) (fma.f64 (/.f64 (.f64 (.f64 (log.f64 re) #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)))))) (log.f64 #s(literal 10 binary64))) #s(literal -24 binary64) (/.f64 #s(literal -3 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 (.f64 (log.f64 re) re) re))) (.f64 im im) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(+ (log (/ (log 10) (log re))) (* (pow im 2) (- (* (pow im 2) (+ (* 1/720 (* (pow im 2) (- (+ (* -720 (/ (* (log re) (+ (* -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))))))) (log 10))) (* -360 (/ (+ (* -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 10))))) (* 30 (/ 1 (* (pow re 6) (pow (log re) 3))))))) (* 1/24 (- (* -24 (/ (* (log re) (+ (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 2)))) (* -1/4 (/ (log 10) (* (pow re 4) (pow (log re) 3)))))) (log 10))) (* 3 (/ 1 (* (pow re 4) (pow (log re) 2)))))))) (* 1/2 (/ 1 (* (pow re 2) (log re)))))))
(fma.f64 (fma.f64 (fma.f64 (.f64 #s(literal 1/720 binary64) (.f64 im im)) (fma.f64 (/.f64 (.f64 (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)))) (log.f64 re)) (log.f64 #s(literal 10 binary64))) #s(literal -720 binary64) (-.f64 (/.f64 (.f64 #s(literal 90 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 #s(literal 10 binary64)) re) re)) (/.f64 #s(literal 30 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64)) (pow.f64 re #s(literal 6 binary64)))))) (.f64 (fma.f64 (/.f64 (.f64 (.f64 (log.f64 re) #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)))))) (log.f64 #s(literal 10 binary64))) #s(literal -24 binary64) (/.f64 #s(literal -3 binary64) (.f64 (pow.f64 (log.f64 re) #s(literal 2 binary64)) (pow.f64 re #s(literal 4 binary64))))) #s(literal 1/24 binary64))) (.f64 im im) (/.f64 #s(literal -1/2 binary64) (.f64 (.f64 (log.f64 re) re) re))) (.f64 im im) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 re))))
(/ (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/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 (/ (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) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (.f64 (pow.f64 im #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 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)))
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) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (.f64 (pow.f64 im #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 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)
(/ (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) (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 (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) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (.f64 (pow.f64 im #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 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/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 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 (/ 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) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (.f64 (pow.f64 im #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 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
(* -1 (log (* -1 (/ (log 10) (log (/ 1 im))))))
(neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))
(-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (.f64 (neg.f64 (log.f64 im)) (.f64 im im))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))) (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4)))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 24 binary64) (neg.f64 (log.f64 im))) (/.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))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal -3 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/24 binary64) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (.f64 (neg.f64 (log.f64 im)) (*.f64 im im))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ 1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 720 (/ (* (log (/ 1 im)) (+ (* -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))))))) (log 10))))) (pow im 6))))))
(-.f64 (fma.f64 (/.f64 #s(literal -1/2 binary64) (neg.f64 (log.f64 im))) (.f64 (/.f64 re im) (/.f64 re im)) (fma.f64 (/.f64 (fma.f64 (.f64 #s(literal -360 binary64) (.f64 re re)) (/.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))))) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (.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)))))) (neg.f64 (log.f64 im))) (log.f64 #s(literal 10 binary64))) #s(literal 720 binary64) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 30 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/720 binary64) (.f64 (/.f64 (fma.f64 (.f64 #s(literal 24 binary64) (neg.f64 (log.f64 im))) (/.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))))) (log.f64 #s(literal 10 binary64))) (/.f64 (*.f64 #s(literal -3 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (pow.f64 im #s(literal 4 binary64))) #s(literal -1/24 binary64)))) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(log (* -1 (/ (log 10) (log (/ 1 im)))))
(log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))
(+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))
(fma.f64 (/.f64 #s(literal 1/2 binary64) (neg.f64 (log.f64 im))) (*.f64 (/.f64 re im) (/.f64 re im)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))
(+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im)))))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 24 binary64) (neg.f64 (log.f64 im))) (/.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))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal -3 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/24 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) (neg.f64 (log.f64 im))) (.f64 (/.f64 re im) (/.f64 re im)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
(+ (log (* -1 (/ (log 10) (log (/ 1 im))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 720 (/ (* (log (/ 1 im)) (+ (* -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))))))) (log 10))))) (pow im 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ 1 im)) 2))) (* 24 (/ (* (log (/ 1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ 1 im))))))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal -360 binary64) (.f64 re re)) (/.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))))) (log.f64 #s(literal 10 binary64))) (fma.f64 (/.f64 (.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)))))) (neg.f64 (log.f64 im))) (log.f64 #s(literal 10 binary64))) #s(literal 720 binary64) (/.f64 (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 30 binary64)) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64))))) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 24 binary64) (neg.f64 (log.f64 im))) (/.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))))) (log.f64 #s(literal 10 binary64))) (/.f64 (.f64 #s(literal -3 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (log.f64 im) #s(literal 2 binary64)))) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/24 binary64) (fma.f64 (/.f64 #s(literal 1/2 binary64) (neg.f64 (log.f64 im))) (.f64 (/.f64 re im) (/.f64 re im)) (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (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) (.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)))))))
(* -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/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 10 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) (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) 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)))
(* -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/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 10 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) (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) 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)))
(/ (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/4 binary64) (log.f64 #s(literal 1/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 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/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/4 binary64) (log.f64 #s(literal 1/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 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))))))
(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/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 10 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) (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) 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/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)))))))
(* -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/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 10 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) (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) im)) (log.f64 #s(literal 10 binary64))))
(* -1 (log (* -1 (/ (log 10) (log (/ -1 im))))))
(neg.f64 (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))
(-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (.f64 im im))) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))) (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4)))))
(fma.f64 (/.f64 (fma.f64 (/.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)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))) #s(literal 24 binary64) (/.f64 (.f64 #s(literal -3 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 -1/24 binary64) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 im im))) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
(+ (* -1 (log (* -1 (/ (log 10) (log (/ -1 im)))))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))) (+ (* -1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4))) (* -1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 720 (/ (* (log (/ -1 im)) (+ (* -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))))))) (log 10))))) (pow im 6))))))
(-.f64 (fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 720 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (/.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))))) (log.f64 #s(literal 10 binary64))) (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 30 binary64) (.f64 (.f64 #s(literal -360 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 #s(literal 10 binary64)))))) (pow.f64 im #s(literal 6 binary64))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (fma.f64 (/.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)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))) #s(literal 24 binary64) (/.f64 (.f64 #s(literal -3 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 -1/24 binary64) (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 im im))))) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(log (* -1 (/ (log 10) (log (/ -1 im)))))
(log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))))
(+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))
(fma.f64 (/.f64 (.f64 re re) (.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (*.f64 im im))) #s(literal 1/2 binary64) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im)))))
(+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im)))))))
(fma.f64 (/.f64 (fma.f64 (/.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)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))) #s(literal 24 binary64) (/.f64 (.f64 #s(literal -3 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 1/24 binary64) (fma.f64 (/.f64 (.f64 re re) (.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (.f64 im im))) #s(literal 1/2 binary64) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) im))))))
(+ (log (* -1 (/ (log 10) (log (/ -1 im))))) (+ (* 1/720 (/ (+ (* -360 (/ (* (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 10))) (+ (* 30 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 720 (/ (* (log (/ -1 im)) (+ (* -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))))))) (log 10))))) (pow im 6))) (+ (* 1/24 (/ (+ (* -3 (/ (pow re 4) (pow (log (/ -1 im)) 2))) (* 24 (/ (* (log (/ -1 im)) (+ (* -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 10)))) (pow im 4))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log (/ -1 im))))))))
(fma.f64 (/.f64 (fma.f64 (.f64 #s(literal 720 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (/.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))))) (log.f64 #s(literal 10 binary64))) (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 30 binary64) (.f64 (.f64 #s(literal -360 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 #s(literal 10 binary64)))))) (pow.f64 im #s(literal 6 binary64))) #s(literal 1/720 binary64) (fma.f64 (/.f64 (fma.f64 (/.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)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (log.f64 #s(literal 10 binary64))) #s(literal 24 binary64) (/.f64 (.f64 #s(literal -3 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 1/24 binary64) (fma.f64 (/.f64 (.f64 re re) (.f64 (log.f64 (/.f64 #s(literal -1 binary64) im)) (.f64 im im))) #s(literal 1/2 binary64) (log.f64 (/.f64 (neg.f64 (log.f64 #s(literal 10 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))))
(- (+ (* -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)))))

rewrite179.0ms (3%)

Memory

-1.7MiB live, 295.4MiB allocated

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	29	114
0	48	105
1	136	104
2	642	103
3	5365	103
0	8214	103

Stop Event

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

Counts

19 → 1 351

Calls

Call 1

Inputs
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(log.f64 (hypot.f64 re im))
(hypot.f64 re 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)
(/.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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))
(pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)))
(*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64))
(log.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)))
(log.f64 #s(literal 1/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>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval418.0ms (6.9%)

Memory: 32.2MiB live, 441.1MiB allocated
Compiler: Compiled 46 540 to 5 626 computations (87.9% saved)

prune72.0ms (1.2%)

Memory

-29.7MiB live, 142.5MiB allocated

Pruning

14 alts after pruning (11 fresh and 3 done)

	Pruned	Kept	Total
New	2 219	10	2 229
Fresh	8	1	9
Picked	2	3	5
Done	0	0	0
Total	2 229	14	2 243

Accuracy

100.0%

Counts

2 243 → 14

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	99.4%	(/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
	97.8%	(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) #s(approx (pow (log (sqrt (+ (* im im) (* re re)))) -1) (/.f64 #s(literal 1 binary64) (log.f64 im))))
	99.0%	(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))))
▶	99.1%	(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64)))
▶	51.8%	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
	51.9%	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
✓	99.1%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
▶	98.3%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	98.3%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
▶	98.1%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	98.2%	(/.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.6%	(.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	68.8%	(exp.f64 #s(approx (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1) (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))

Compiler

Compiled 249 to 242 computations (2.8% saved)

simplify63.0ms (1%)

Memory

-0.4MiB live, 36.9MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	(log.f64 (hypot.f64 im re))
cost-diff	0	(/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))
cost-diff	0	(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64)))
cost-diff	1408	(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))))
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 #s(literal 10 binary64))
cost-diff	0	(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64))
cost-diff	0	(pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64))
cost-diff	6848	(/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))

Iterations

Useful iterations: 2 (0.0ms)

Iter	Nodes	Cost
0	36	223
0	58	187
1	75	185
2	100	181
3	151	181
4	252	181
5	469	181
6	737	181
7	1096	181
8	1555	181
9	1826	181
10	1905	181
11	1966	181
12	2092	181
13	2092	181
0	2092	181

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
(pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(literal -1/4 binary64)
#s(literal 4 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
#s(literal -1 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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))))
#s(literal -1 binary64)
(/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))
(log.f64 (hypot.f64 im re))
(hypot.f64 im re)
im
re
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)

Outputs
(/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
(*.f64 (log.f64 (hypot.f64 re im)) (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)))
(pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(literal -1/4 binary64)
#s(literal 4 binary64)
(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
#s(literal -1 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 re re (.f64 im im))))
(.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 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
#s(literal 1/2 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))))
(log.f64 (hypot.f64 re im))
#s(literal -1 binary64)
(/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))
(/.f64 #s(literal -1 binary64) (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 10 binary64))
#s(literal 10 binary64)

localize126.0ms (2.1%)

Memory

22.4MiB live, 265.9MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.28125	(/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))))
accuracy	0.3046875	(/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))
accuracy	0.5840225586106522	(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64)))
accuracy	0	(*.f64 re re)
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.5840225586106522	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
accuracy	30.50866189745302	(log.f64 (fma.f64 im im (*.f64 re re)))
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.26953125	(/.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.5291350786000174	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.6582413086106522	(/.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.5291350786000174	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.5840225586106522	(/.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	(log.f64 (hypot.f64 im re))
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.2734375	(/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
accuracy	0.3046875	(pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))

Samples

104.0ms

256×

valid

Compiler

Compiled 256 to 35 computations (86.3% saved)

Precisions

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

ival-pow: 30.0ms (35.6% of total)

ival-log: 20.0ms (23.7% of total)

ival-div: 12.0ms (14.2% of total)

ival-mult: 8.0ms (9.5% of total)

ival-hypot: 8.0ms (9.5% of total)

const: 4.0ms (4.7% of total)

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

exact: 1.0ms (1.2% of total)

ival-neg: 1.0ms (1.2% of total)

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

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

series193.0ms (3.2%)

Memory

-3.9MiB live, 73.2MiB allocated

Counts

21 → 384

Calls

Call 1

Inputs
#s(alt (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<representation binary64>) () ())
#s(alt (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (patch (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) #<representation binary64>) () ())
#s(alt (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) (patch (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #<representation binary64>) () ())
#s(alt (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 binary64)) #<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 #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 #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 (/.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 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())
#s(alt (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (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 (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.f64 #s(literal 1/10 binary64)) (patch (log.f64 #s(literal 1/10 binary64)) #<representation binary64>) () ())
#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())

Outputs
#s(alt (/ (log im) (log 10)) (taylor 0 re) (#s(alt (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (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 10)))) (/ (log im) (log 10))) (taylor 0 re) (#s(alt (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) #<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) (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 (/ (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 (log im) (taylor 0 re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (/ (log im) (log 10)) (taylor 0 re) (#s(alt (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log im)) (taylor 0 re) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/2 (/ (pow re 2) (* (pow im 2) (pow (log im) 2)))) (/ 1 (log im))) (taylor 0 re) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<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 (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow re 2) (+ (* (pow re 2) (- (* (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 (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (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 (/ 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 (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 (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (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 #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))) (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 (* -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 (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 re)) (log 10))) (taylor inf re) (#s(alt (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ 1 re))) (taylor inf re) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im 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 -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2)))) (pow re 4))) (/ 1 (log (/ 1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2))))) (taylor inf re) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ 1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))))) (pow re 6))) (/ 1 (log (/ 1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2))))))) (taylor inf re) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (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 (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 (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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (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 #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))) (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 (* -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 (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 re)) (log 10))) (taylor -inf re) (#s(alt (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ -1 re))) (taylor -inf re) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im 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 -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2)))) (pow re 4))) (/ 1 (log (/ -1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2))))) (taylor -inf re) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ -1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))))) (pow re 6))) (/ 1 (log (/ -1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2))))))) (taylor -inf re) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (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 (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 (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 (/ (log re) (log 10)) (taylor 0 im) (#s(alt (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (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 10)))) (/ (log re) (log 10))) (taylor 0 im) (#s(alt (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (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 #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) (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 (/ (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 (log re) (taylor 0 im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (/ (log re) (log 10)) (taylor 0 im) (#s(alt (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ -1 (log re)) (taylor 0 im) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* 1/2 (/ (pow im 2) (* (pow re 2) (pow (log re) 2)))) (/ 1 (log re))) (taylor 0 im) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<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 (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (* (pow im 2) (+ (* (pow im 2) (- (* (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 (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (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 (/ 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 (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (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 #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))) (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 (* -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 (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ 1 im)) (log 10))) (taylor inf im) (#s(alt (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ 1 im))) (taylor inf im) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im 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 -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2)))) (pow im 4))) (/ 1 (log (/ 1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2))))) (taylor inf im) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ 1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))))) (pow im 6))) (/ 1 (log (/ 1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2))))))) (taylor inf im) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (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 (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 (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))) (patch (/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (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 #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))) (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 (* -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 (* -1 (log (/ -1 im))) (taylor -inf im) (#s(alt (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (patch (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (/ (log (/ -1 im)) (log 10))) (taylor -inf im) (#s(alt (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())) ())
#s(alt (/ 1 (log (/ -1 im))) (taylor -inf im) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im 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 -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2)))) (pow im 4))) (/ 1 (log (/ -1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2))))) (taylor -inf im) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) #<representation binary64>) () ())) ())
#s(alt (- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ -1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))))) (pow im 6))) (/ 1 (log (/ -1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2))))))) (taylor -inf im) (#s(alt (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))) (patch (/.f64 #s(literal -1 binary64) (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 (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
140.0ms	re	@	0	((/ (pow (pow (log 10) -1/4) 4) (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (pow (log 10) -1/4) 4) (pow (log 10) -1/4) (log 10) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (/ (* (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 (/ -1 (log (sqrt (+ (* im im) (* re re)))))) (/ (/ -1 (/ -1 (log (sqrt (+ (* im im) (* re re)))))) (log 10)) (/ -1 (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (pow (log (sqrt (+ (* im im) (* re re)))) -1) (log 1/10) (* re re))
12.0ms	im	@	-inf	((/ (pow (pow (log 10) -1/4) 4) (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (pow (log 10) -1/4) 4) (pow (log 10) -1/4) (log 10) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (/ (* (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 (/ -1 (log (sqrt (+ (* im im) (* re re)))))) (/ (/ -1 (/ -1 (log (sqrt (+ (* im im) (* re re)))))) (log 10)) (/ -1 (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (pow (log (sqrt (+ (* im im) (* re re)))) -1) (log 1/10) (* re re))
10.0ms	im	@	inf	((/ (pow (pow (log 10) -1/4) 4) (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (pow (log 10) -1/4) 4) (pow (log 10) -1/4) (log 10) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (/ (* (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 (/ -1 (log (sqrt (+ (* im im) (* re re)))))) (/ (/ -1 (/ -1 (log (sqrt (+ (* im im) (* re re)))))) (log 10)) (/ -1 (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (pow (log (sqrt (+ (* im im) (* re re)))) -1) (log 1/10) (* re re))
9.0ms	im	@	0	((/ (pow (pow (log 10) -1/4) 4) (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (pow (log 10) -1/4) 4) (pow (log 10) -1/4) (log 10) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (/ (* (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 (/ -1 (log (sqrt (+ (* im im) (* re re)))))) (/ (/ -1 (/ -1 (log (sqrt (+ (* im im) (* re re)))))) (log 10)) (/ -1 (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (pow (log (sqrt (+ (* im im) (* re re)))) -1) (log 1/10) (* re re))
3.0ms	re	@	inf	((/ (pow (pow (log 10) -1/4) 4) (pow (log (sqrt (+ (* im im) (* re re)))) -1)) (pow (pow (log 10) -1/4) 4) (pow (log 10) -1/4) (log 10) (/ (neg (log (sqrt (+ (* re re) (* im im))))) (log 1/10)) (neg (log (sqrt (+ (* re re) (* im im))))) (log (sqrt (+ (* re re) (* im im)))) (log im) (/ 1 (/ (log 10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 10) (log (sqrt (+ (* re re) (* im im))))) (/ (* (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 (/ -1 (log (sqrt (+ (* im im) (* re re)))))) (/ (/ -1 (/ -1 (log (sqrt (+ (* im im) (* re re)))))) (log 10)) (/ -1 (log (sqrt (+ (* im im) (* re re))))) (log (sqrt (+ (* im im) (* re re)))) (pow (log (sqrt (+ (* im im) (* re re)))) -1) (log 1/10) (* re re))

simplify210.0ms (3.5%)

Memory

-8.4MiB live, 203.1MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	967	9912
1	2930	9594
0	8567	9144

Stop Event

1×	iter limit
1×	node limit

Counts

384 → 384

Calls

Call 1

Inputs
(/ (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)))
(* -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))))))
(/ (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))
(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))))))
(/ (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)))
(/ -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/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 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))
(+ (* -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)))
(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)))))))
(/ (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 (/ (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))))
(* -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 (/ (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/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)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2)))) (pow re 4))) (/ 1 (log (/ 1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ 1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))))) (pow re 6))) (/ 1 (log (/ 1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (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))))))
(/ -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)))))))
(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)))))))
(/ (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 (/ (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))))
(* -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 (/ (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/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)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2)))) (pow re 4))) (/ 1 (log (/ -1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ -1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))))) (pow re 6))) (/ 1 (log (/ -1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (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))))))
(/ -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)))))))
(pow re 2)
(pow re 2)
(pow re 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)))
(* -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))))))
(log im)
(log im)
(log im)
(log im)
(/ (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))
(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)))
(/ -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/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 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 (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)))
(* -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)))))))
(/ (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 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -1 (log (/ 1 im)))
(* -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))))
(* -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 (/ 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)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2)))) (pow im 4))) (/ 1 (log (/ 1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ 1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))))) (pow im 6))) (/ 1 (log (/ 1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (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))))))
(/ -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)))))))
(* -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)))))))
(/ (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))))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(+ (log -1) (* -1 (log (/ -1 im))))
(* -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))))
(* -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 (/ -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)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2)))) (pow im 4))) (/ 1 (log (/ -1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ -1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))))) (pow im 6))) (/ 1 (log (/ -1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (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))))))
(/ -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
(/ (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 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 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))))
(* -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) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) (pow.f64 im #s(literal 6 binary64))) (/.f64 #s(literal 1/4 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) (pow.f64 im #s(literal 4 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 (/.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))
(/ (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 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 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 (neg.f64 (.f64 re re)) (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))) (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))) (/.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/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) (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)))
(+ (* 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 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 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))
(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))
(/ (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 (pow.f64 im #s(literal 4 binary64)) (log.f64 #s(literal 10 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))))
(/ -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 (neg.f64 (.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/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 (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 (/.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)))
(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))
(/.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 (neg.f64 (.f64 re re)) (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 (/.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)))
(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/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (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 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) (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 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)))))
(/ (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/4 binary64) (log.f64 #s(literal 1/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 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/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/4 binary64) (log.f64 #s(literal 1/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 1/10 binary64))) (.f64 (/.f64 im re) (/.f64 im re)) (/.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)))
(* -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/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (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 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) (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 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 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)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (.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)))))) (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)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) (.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 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/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (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 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))
(* -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)))
(* -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/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)) (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 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) (.f64 (pow.f64 im #s(literal 6 binary64)) #s(literal 120 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)))
(/.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)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2)))) (pow re 4))) (/ 1 (log (/ 1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 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/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ 1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))))) (pow re 6))) (/ 1 (log (/ 1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 2)))))))
(-.f64 (-.f64 (/.f64 #s(literal -1 binary64) (log.f64 re)) (/.f64 (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) (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) (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (fma.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 binary64))))) (.f64 im im)) (log.f64 re))))) (pow.f64 re #s(literal 6 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))) (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)))) (.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)))))))
(* -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)))
(/ -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)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 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)) (pow.f64 (log.f64 re) #s(literal 2 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 im #s(literal 4 binary64))) (neg.f64 (pow.f64 (log.f64 re) #s(literal 3 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))))))
(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/2 binary64) (log.f64 #s(literal 10 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)) (log.f64 #s(literal 10 binary64))) (/.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) re)) (log.f64 #s(literal 10 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/4 binary64) (log.f64 #s(literal 1/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 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/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/4 binary64) (log.f64 #s(literal 1/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 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))))))
(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 (/.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)))
(* -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/2 binary64) (log.f64 #s(literal 10 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)) (log.f64 #s(literal 10 binary64))) (/.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) 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 (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 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 (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 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 (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))) (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 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 (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))
(* -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)))
(* -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/2 binary64) (log.f64 #s(literal 10 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)) (log.f64 #s(literal 10 binary64))) (/.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) 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)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2)))) (pow re 4))) (/ 1 (log (/ -1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(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 2 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 3 binary64)))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 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/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ -1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))))) (pow re 6))) (/ 1 (log (/ -1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 2)))))))
(-.f64 (-.f64 (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) re))) (/.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 2 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 3 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) re))) (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) (/.f64 (.f64 #s(literal -1/720 binary64) (.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))))) (pow.f64 re #s(literal 6 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) (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) (*.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)))))
(* -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)))
(/ -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 2 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 3 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 2 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 3 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)))))))
(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 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))))
(* -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))
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 im)
(log im)
(log.f64 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) (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 (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 (.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 (/.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) (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 (/.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))
(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))))
(/ -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 (neg.f64 (.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/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 (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 (/.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)))
(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 (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 (neg.f64 (.f64 im im)) (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 (/.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)))
(* -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/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (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 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) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (.f64 (pow.f64 im #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 re im) (/.f64 re im)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 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/4 binary64) (log.f64 #s(literal 1/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 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/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) (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 (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.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)
(* -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/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (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 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) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (.f64 (pow.f64 im #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 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 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (.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))))) (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 (neg.f64 (log.f64 im)) #s(literal 3 binary64))) (.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 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)))))))
(* -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/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (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 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 (pow.f64 im #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 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))
(* -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 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/2 binary64) (log.f64 #s(literal 10 binary64))) (*.f64 (/.f64 re im) (/.f64 re im)) (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 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) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (.f64 (pow.f64 im #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 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)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2)))) (pow im 4))) (/ 1 (log (/ 1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(fma.f64 (/.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 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 re im) (/.f64 re im)) (/.f64 #s(literal -1 binary64) (log.f64 im))))
(- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ 1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))))) (pow im 6))) (/ 1 (log (/ 1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 2)))))))
(-.f64 (-.f64 (/.f64 #s(literal -1 binary64) (log.f64 im)) (/.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 #s(literal -1/2 binary64) (/.f64 (.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))) (.f64 re re)) (log.f64 im)) (/.f64 (.f64 #s(literal -1/720 binary64) (.f64 (pow.f64 re #s(literal 6 binary64)) #s(literal 120 binary64))) (pow.f64 (log.f64 im) #s(literal 2 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 re im) (/.f64 re 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))) (*.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)))))))
(* -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)))
(/.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 (log.f64 im) #s(literal 2 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 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) (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 (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 (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) (.f64 #s(literal -1/2 binary64) (/.f64 (.f64 (fma.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/4 binary64) (pow.f64 re #s(literal 4 binary64))) (pow.f64 (neg.f64 (log.f64 im)) #s(literal 3 binary64)))) (.f64 re re)) (log.f64 im))))) (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) (log.f64 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/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (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 10 binary64))) (/.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) im)) (log.f64 #s(literal 10 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/4 binary64) (log.f64 #s(literal 1/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 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/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/4 binary64) (log.f64 #s(literal 1/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 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))))))
(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)))
(+ (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)))
(* -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/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (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 10 binary64))) (/.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) 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) (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/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 (pow.f64 im #s(literal 6 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 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))
(* -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/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 re im) (/.f64 re im)) (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 10 binary64))) (/.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) 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)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2)))) (pow im 4))) (/ 1 (log (/ -1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(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 2 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 3 binary64)))) (pow.f64 im #s(literal 4 binary64))) #s(literal -1 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/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ -1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))))) (pow im 6))) (/ 1 (log (/ -1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 2)))))))
(-.f64 (-.f64 (/.f64 #s(literal 1 binary64) (log.f64 (/.f64 #s(literal -1 binary64) im))) (/.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 2 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 3 binary64)))) (log.f64 (/.f64 #s(literal -1 binary64) im))) (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) (/.f64 (.f64 #s(literal -1/720 binary64) (.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))))) (pow.f64 im #s(literal 6 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) (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) (*.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)))))
(* -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)))
(/.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 2 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 3 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 2 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 3 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)))))))

rewrite180.0ms (3%)

Memory

-21.7MiB live, 169.5MiB allocated

Iterations

Useful iterations: 1 (0.0ms)

Iter	Nodes	Cost
0	36	174
0	58	149
1	172	120
2	817	120
3	5668	120
0	8185	120

Stop Event

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

Counts

21 → 1 112

Calls

Call 1

Inputs
(/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
(pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64))
(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)))
(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)
(/.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)))
(/.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 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))))
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))
(log.f64 (hypot.f64 im re))
(pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64))
(log.f64 #s(literal 1/10 binary64))
(*.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>

eval259.0ms (4.3%)

Memory: 46.4MiB live, 338.1MiB allocated
Compiler: Compiled 36 924 to 4 377 computations (88.1% saved)

prune46.0ms (0.8%)

Memory

-26.3MiB live, 120.0MiB allocated

Pruning

17 alts after pruning (11 fresh and 6 done)

	Pruned	Kept	Total
New	1 740	9	1 749
Fresh	4	2	6
Picked	2	3	5
Done	0	3	3
Total	1 746	17	1 763

Accuracy

100.0%

Counts

1 763 → 17

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	69.3%	(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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) #s(approx (pow (log (sqrt (+ (* im im) (* re re)))) -1) (/.f64 #s(literal 1 binary64) (log.f64 im))))
▶	98.2%	(/.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.3%	(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
	98.2%	(/.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))))
✓	51.8%	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
▶	98.9%	(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
▶	51.9%	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
	98.1%	(/.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))))
✓	99.1%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
✓	98.3%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	98.3%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
✓	98.1%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	98.2%	(/.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.2%	(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	68.9%	(exp.f64 (log.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))))

Compiler

Compiled 298 to 289 computations (3% saved)

simplify14.0ms (0.2%)

Memory

13.5MiB live, 13.5MiB 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	(/.f64 #s(literal -1 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 -1 binary64))
cost-diff	7040	(/.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))))
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 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
cost-diff	0	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (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	(fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))
cost-diff	0	#s(approx (log (+ (* im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im))))
cost-diff	0	(.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64))
cost-diff	0	(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	38	312
0	60	301
1	81	295
2	104	293
3	131	293
4	146	293
5	201	293
6	240	293
7	261	293
8	295	293
9	330	293
10	375	293
11	401	293
0	401	253

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im))))
(fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))
(/.f64 re im)
re
im
(*.f64 #s(literal 2 binary64) (log.f64 im))
#s(literal 2 binary64)
(log.f64 im)
#s(literal 1/2 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 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))))
#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 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
(.f64 #s(literal -1/2 binary64) (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
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.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 (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)
(/.f64 #s(literal -1 binary64) #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
(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 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 (/.f64 re im) im) re (*.f64 (log.f64 im) #s(literal 2 binary64)))))
(.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64))
(.f64 #s(literal 1/2 binary64) #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 (/.f64 re im) im) re (*.f64 (log.f64 im) #s(literal 2 binary64)))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (/.f64 (/.f64 re im) im) re (*.f64 (log.f64 im) #s(literal 2 binary64))))
(fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))
(fma.f64 (/.f64 (/.f64 re im) im) re (*.f64 (log.f64 im) #s(literal 2 binary64)))
(/.f64 re im)
re
im
(*.f64 #s(literal 2 binary64) (log.f64 im))
(*.f64 (log.f64 im) #s(literal 2 binary64))
#s(literal 2 binary64)
(log.f64 im)
#s(literal 1/2 binary64)
(log.f64 #s(literal 10 binary64))
#s(literal 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(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 im im (.f64 re re)))) (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 im im (.f64 re re))))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64))
#s(literal -1/2 binary64)
(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
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.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))))
(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 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)
(/.f64 #s(literal -1 binary64) #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
(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)

localize123.0ms (2%)

Memory

-20.7MiB live, 206.7MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.0703125	(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.37728500976844204	(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.40284441697312884	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.4043350586106521	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
accuracy	0.20703125	(/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
accuracy	0.40284441697312884	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.70703125	(pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
accuracy	0.70703125	(log.f64 #s(literal 1/10 binary64))
accuracy	0	(.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
accuracy	0.4043350586106521	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
accuracy	0.70703125	(log.f64 #s(literal 1/10 binary64))
accuracy	25.18173757217699	(log.f64 (fma.f64 im im (*.f64 re re)))
accuracy	0.2109375	(/.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.40284441697312884	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.4716987793053261	(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)))
accuracy	0.70703125	(log.f64 #s(literal 1/10 binary64))
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.01171875	(fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))
accuracy	0.09723185418740717	#s(approx (log (+ (* im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im))))
accuracy	0.4043350586106521	(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))

Samples

63.0ms	181×	0	valid
25.0ms	75×	0	invalid

Compiler

Compiled 256 to 35 computations (86.3% saved)

Precisions

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

ival-log: 19.0ms (31.1% of total)

ival-div: 12.0ms (19.6% of total)

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

ival-pow: 5.0ms (8.2% of total)

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

const: 4.0ms (6.5% of total)

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

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

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

exact: 1.0ms (1.6% of total)

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

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

series158.0ms (2.6%)

Memory

5.9MiB live, 128.6MiB allocated

Counts

19 → 384

Calls

Call 1

Inputs
#s(alt (/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) (patch (/.f64 (.f64 #s(approx (log (+ (* im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64))) #<representation binary64>) () ())
#s(alt (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (patch (.f64 #s(approx (log (+ (* im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) #<representation binary64>) () ())
#s(alt #s(approx (log (+ (* im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 #s(literal 2 binary64) (log.f64 im)))) (patch #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #<representation binary64>) () ())
#s(alt (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 #s(literal 2 binary64) (log.f64 im))) (patch (fma.f64 (/.f64 re im) (/.f64 re im) (.f64 #s(literal 2 binary64) (log.f64 im))) #<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 (log.f64 #s(literal 1/10 binary64)) (patch (log.f64 #s(literal 1/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 (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))) (patch (/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64))) #<representation binary64>) () ())
#s(alt (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (patch (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) #<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 (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)))) (patch (/.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)))) #<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 (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (patch (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) #<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 (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 binary64)) #<representation binary64>) () ())

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

Calls

6 calls:

Time	Variable		Point	Expression
24.0ms	im	@	-inf	((/ (* (log (+ (* im im) (* re re))) 1/2) (log 10)) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* (/ re im) (/ re im)) (* 2 (log im))) (/ -1 (/ (log 1/10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 1/10) (log (sqrt (+ (* re re) (* im im))))) (log 1/10) (log (sqrt (+ (* re re) (* im im)))) (/ (* -1/2 (log (+ (* im im) (* re re)))) (log 1/10)) (* -1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ (pow (log 1/10) -1) (/ -1 (log (sqrt (+ (* re re) (* im im)))))) (pow (log 1/10) -1) (/ -1 (log (sqrt (+ (* re re) (* im im))))) (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)) (log 10))
8.0ms	re	@	0	((/ (* (log (+ (* im im) (* re re))) 1/2) (log 10)) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* (/ re im) (/ re im)) (* 2 (log im))) (/ -1 (/ (log 1/10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 1/10) (log (sqrt (+ (* re re) (* im im))))) (log 1/10) (log (sqrt (+ (* re re) (* im im)))) (/ (* -1/2 (log (+ (* im im) (* re re)))) (log 1/10)) (* -1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ (pow (log 1/10) -1) (/ -1 (log (sqrt (+ (* re re) (* im im)))))) (pow (log 1/10) -1) (/ -1 (log (sqrt (+ (* re re) (* im im))))) (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)) (log 10))
8.0ms	re	@	inf	((/ (* (log (+ (* im im) (* re re))) 1/2) (log 10)) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* (/ re im) (/ re im)) (* 2 (log im))) (/ -1 (/ (log 1/10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 1/10) (log (sqrt (+ (* re re) (* im im))))) (log 1/10) (log (sqrt (+ (* re re) (* im im)))) (/ (* -1/2 (log (+ (* im im) (* re re)))) (log 1/10)) (* -1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ (pow (log 1/10) -1) (/ -1 (log (sqrt (+ (* re re) (* im im)))))) (pow (log 1/10) -1) (/ -1 (log (sqrt (+ (* re re) (* im im))))) (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)) (log 10))
7.0ms	im	@	inf	((/ (* (log (+ (* im im) (* re re))) 1/2) (log 10)) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* (/ re im) (/ re im)) (* 2 (log im))) (/ -1 (/ (log 1/10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 1/10) (log (sqrt (+ (* re re) (* im im))))) (log 1/10) (log (sqrt (+ (* re re) (* im im)))) (/ (* -1/2 (log (+ (* im im) (* re re)))) (log 1/10)) (* -1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ (pow (log 1/10) -1) (/ -1 (log (sqrt (+ (* re re) (* im im)))))) (pow (log 1/10) -1) (/ -1 (log (sqrt (+ (* re re) (* im im))))) (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)) (log 10))
5.0ms	im	@	0	((/ (* (log (+ (* im im) (* re re))) 1/2) (log 10)) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* (/ re im) (/ re im)) (* 2 (log im))) (/ -1 (/ (log 1/10) (log (sqrt (+ (* re re) (* im im)))))) (/ (log 1/10) (log (sqrt (+ (* re re) (* im im))))) (log 1/10) (log (sqrt (+ (* re re) (* im im)))) (/ (* -1/2 (log (+ (* im im) (* re re)))) (log 1/10)) (* -1/2 (log (+ (* im im) (* re re)))) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (/ (pow (log 1/10) -1) (/ -1 (log (sqrt (+ (* re re) (* im im)))))) (pow (log 1/10) -1) (/ -1 (log (sqrt (+ (* re re) (* im im))))) (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)) (log 10))

simplify209.0ms (3.5%)

Memory

5.3MiB live, 231.3MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	1099	10687
1	3281	10343
0	8343	9861

Stop Event

1×	iter limit
1×	node limit

Counts

384 → 384

Calls

Call 1

Inputs
(* 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)))))
(* 2 (log im))
(+ (* 2 (log im)) (/ (pow re 2) (pow im 2)))
(+ (* 2 (log im)) (/ (pow re 2) (pow im 2)))
(+ (* 2 (log im)) (/ (pow re 2) (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)))))))
(/ (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 (/ (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/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 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)))
(* -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 im 2))
(* (pow re 2) (+ (* 2 (/ (log im) (pow re 2))) (/ 1 (pow im 2))))
(* (pow re 2) (+ (* 2 (/ (log im) (pow re 2))) (/ 1 (pow im 2))))
(* (pow re 2) (+ (* 2 (/ (log im) (pow re 2))) (/ 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 (/ (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))))
(/ (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 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2)))) (pow re 4))) (/ 1 (log (/ 1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))))
(- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ 1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ 1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ 1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ 1 re)) 2))))) (log (/ 1 re)))))) (pow re 6))) (/ 1 (log (/ 1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ 1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ 1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (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)))))))
(* -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 im 2))
(* (pow re 2) (+ (* 2 (/ (log im) (pow re 2))) (/ 1 (pow im 2))))
(* (pow re 2) (+ (* 2 (/ (log im) (pow re 2))) (/ 1 (pow im 2))))
(* (pow re 2) (+ (* 2 (/ (log im) (pow re 2))) (/ 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 (/ (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))))
(/ (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 (/ (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2)))) (pow re 4))) (/ 1 (log (/ -1 re)))) (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))))
(- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow (log (/ -1 re)) 2))) (+ (* 1/8 (/ (pow im 6) (pow (log (/ -1 re)) 3))) (* 1/2 (/ (* (pow im 2) (+ (* -1/4 (/ (pow im 4) (pow (log (/ -1 re)) 3))) (* 1/4 (/ (pow im 4) (pow (log (/ -1 re)) 2))))) (log (/ -1 re)))))) (pow re 6))) (/ 1 (log (/ -1 re)))) (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (pow (log (/ -1 re)) 2)))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (pow (log (/ -1 re)) 3)))) (* 1/4 (/ (pow im 4) (* (pow re 4) (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)))))))
(* 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))
(/ (+ (* 2 (* (pow im 2) (log im))) (pow re 2)) (pow im 2))
(/ (+ (* 2 (* (pow im 2) (log im))) (pow re 2)) (pow im 2))
(/ (+ (* 2 (* (pow im 2) (log im))) (pow re 2)) (pow im 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 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 (/ (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/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 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)))
(* -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)))))
(* -2 (log (/ 1 im)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))
(+ (* -2 (log (/ 1 im))) (/ (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/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))))
(/ (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 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2)))) (pow im 4))) (/ 1 (log (/ 1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))))
(- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ 1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ 1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ 1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ 1 im)) 2))))) (log (/ 1 im)))))) (pow im 6))) (/ 1 (log (/ 1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ 1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ 1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (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)))))))
(* -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)))))
(* 2 (+ (log -1) (* -1 (log (/ -1 im)))))
(+ (* 2 (+ (log -1) (* -1 (log (/ -1 im))))) (/ (pow re 2) (pow im 2)))
(+ (* 2 (+ (log -1) (* -1 (log (/ -1 im))))) (/ (pow re 2) (pow im 2)))
(+ (* 2 (+ (log -1) (* -1 (log (/ -1 im))))) (/ (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/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))))
(/ (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 (/ (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2)))) (pow im 4))) (/ 1 (log (/ -1 im)))) (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))))
(- (+ (* -1 (/ (+ (* -1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow (log (/ -1 im)) 2))) (+ (* 1/8 (/ (pow re 6) (pow (log (/ -1 im)) 3))) (* 1/2 (/ (* (pow re 2) (+ (* -1/4 (/ (pow re 4) (pow (log (/ -1 im)) 3))) (* 1/4 (/ (pow re 4) (pow (log (/ -1 im)) 2))))) (log (/ -1 im)))))) (pow im 6))) (/ 1 (log (/ -1 im)))) (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (pow (log (/ -1 im)) 2)))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (pow (log (/ -1 im)) 3)))) (* 1/4 (/ (pow re 4) (* (pow im 4) (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)))))))

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

rewrite183.0ms (3%)

Memory

5.1MiB live, 226.3MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	38	245
0	60	230
1	189	221
2	1089	221
0	8341	177

Stop Event

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

Counts

19 → 848

Calls

Call 1

Inputs
(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im))))
(fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))
(/.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)))
(log.f64 #s(literal 1/10 binary64))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 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))
(/.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 (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 (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)))
(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>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>
#<batchref>

eval232.0ms (3.8%)

Memory: 6.8MiB live, 302.9MiB allocated
Compiler: Compiled 29 945 to 3 961 computations (86.8% saved)

prune40.0ms (0.7%)

Memory

10.8MiB live, 123.5MiB allocated

Pruning

21 alts after pruning (12 fresh and 9 done)

	Pruned	Kept	Total
New	1 360	7	1 367
Fresh	1	5	6
Picked	2	3	5
Done	0	6	6
Total	1 363	21	1 384

Accuracy

100.0%

Counts

1 384 → 21

Alt Table

Click to see full alt table

Status	Accuracy	Program
	69.2%	(pow.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))) #s(literal 2 binary64))
	69.3%	(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 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) #s(approx (pow (log (sqrt (+ (* im im) (* re re)))) -1) (/.f64 #s(literal 1 binary64) (log.f64 im))))
	98.2%	(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	98.3%	(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
✓	51.8%	(/.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
	98.9%	(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	98.9%	(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
	3.5%	(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) #s(approx (+ (* (/ re im) (/ re im)) (* 2 (log im))) (*.f64 (/.f64 re im) (/.f64 re im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
✓	51.9%	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 1/10 binary64)))
	98.1%	(/.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))))
✓	99.1%	(/.f64 (neg.f64 (log.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))
✓	98.3%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
✓	98.3%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
✓	98.1%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	98.2%	(/.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.2%	(/.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.1%	(/.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 10 binary64))))
	69.8%	(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)))
	68.9%	(exp.f64 (log.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))))

Compiler

Compiled 674 to 342 computations (49.3% saved)

regimes143.0ms (2.4%)

Memory

-22.7MiB live, 187.6MiB allocated

Counts

41 → 1

Calls

Call 1

Inputs
(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) #s(approx (+ (* (/ re im) (/ re im)) (* 2 (log im))) (*.f64 (/.f64 re im) (/.f64 re im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.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 (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 10 binary64))))
(/.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 im im (.f64 re re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.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 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.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)) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) #s(approx (pow (log (sqrt (+ (* im im) (* re re)))) -1) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(pow.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))) #s(literal 2 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64)))
(exp.f64 (log.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))))
(exp.f64 #s(approx (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1) (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(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 (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 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))))
(/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) #s(approx (pow (log (sqrt (+ (* im im) (* re re)))) -1) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)))
(/.f64 (log.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (/.f64 (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 binary64)) #s(literal 1 binary64)) #s(literal -1 binary64)))
(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))

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

Calls

8 calls:

39.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
20.0ms	(*.f64 re re)
18.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
14.0ms	im
11.0ms	re

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes125.0ms (2.1%)

Memory

6.4MiB live, 203.5MiB allocated

Counts

38 → 1

Calls

Call 1

Inputs
(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) #s(approx (+ (* (/ re im) (/ re im)) (* 2 (log im))) (*.f64 (/.f64 re im) (/.f64 re im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.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 (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 10 binary64))))
(/.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 im im (.f64 re re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.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 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
(/.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)) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) #s(approx (pow (log (sqrt (+ (* im im) (* re re)))) -1) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(pow.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))) #s(literal 2 binary64))
(/.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re)))) (log.f64 #s(literal 10 binary64)))
(exp.f64 (log.f64 (/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))))
(exp.f64 #s(approx (* (log (/ (log 10) (log (sqrt (+ (* im im) (* re re)))))) -1) (neg.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im))))))
(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 (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 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 (hypot.f64 im re))))
(/.f64 (pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/4 binary64)) #s(literal 4 binary64)) #s(approx (pow (log (sqrt (+ (* im im) (* re re)))) -1) (/.f64 #s(literal 1 binary64) (log.f64 im))))
(.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) (.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1/2 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (hypot.f64 im re)) #s(literal -1 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))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (hypot.f64 im re)))) #s(literal -1 binary64)))
(/.f64 (log.f64 (pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (fma.f64 im im (*.f64 re re))))) (log.f64 #s(literal 10 binary64)))

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

Calls

8 calls:

42.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
15.0ms	im
12.0ms	re
12.0ms	(+.f64 (.f64 re re) (.f64 im im))
12.0ms	(*.f64 re 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)

regimes42.0ms (0.7%)

Memory

8.8MiB live, 85.1MiB allocated

Counts

15 → 1

Calls

Call 1

Inputs
(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) #s(approx (+ (* (/ re im) (/ re im)) (* 2 (log im))) (*.f64 (/.f64 re im) (/.f64 re im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.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 (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 10 binary64))))
(/.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 im im (.f64 re re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.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 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) (fma.f64 (/.f64 re im) (/.f64 re im) (*.f64 #s(literal 2 binary64) (log.f64 im)))) #s(literal 1/2 binary64)) (neg.f64 (log.f64 #s(literal 1/10 binary64))))

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

Calls

8 calls:

7.0ms	re
6.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
5.0ms	im
5.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
5.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes41.0ms (0.7%)

Memory

12.2MiB live, 91.1MiB allocated

Counts

13 → 1

Calls

Call 1

Inputs
(/.f64 (.f64 #s(approx (log (+ ( im im) (* re re))) #s(approx (+ (* (/ re im) (/ re im)) (* 2 (log im))) (*.f64 (/.f64 re im) (/.f64 re im)))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(/.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 (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 10 binary64))))
(/.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 im im (.f64 re re)))) (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 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* im im) (* re re)))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (/.f64 #s(literal 1 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1 binary64) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
(/.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))))

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

Calls

8 calls:

9.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
6.0ms	im
5.0ms	re
4.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
4.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes15.0ms (0.2%)

Memory

3.5MiB live, 39.7MiB allocated

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

1 → 1

Calls

Call 1

Inputs

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

Outputs

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

simplify27.0ms (0.5%)

Memory

-25.3MiB live, 78.9MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	44	94
1	47	94

Stop Event

1×

saturated

Calls

Call 1

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

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

soundness814.0ms (13.5%)

Memory

36.4MiB live, 602.5MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	967	9912
1	2930	9594
0	8567	9144
0	10	41
0	17	41
1	44	41
2	251	41
3	2046	41
0	8387	25
0	268	1676
1	730	1632
2	2203	1630
3	5799	1618
0	8392	1506
0	1099	10687
1	3281	10343
0	8343	9861
0	29	114
0	48	105
1	136	104
2	642	103
3	5365	103
0	8214	103

Stop Event

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

Compiler

Compiled 250 to 146 computations (41.6% saved)

preprocess93.0ms (1.5%)

Memory

0.5MiB live, 138.6MiB allocated

Remove

(sort re im)

(abs re)

(abs im)

Compiler

Compiled 294 to 240 computations (18.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	29	150
0	48	142
1	63	141
2	81	141
3	100	141
4	128	141
5	178	141
6	263	141
7	371	141
8	414	141
9	432	141
10	446	141
11	459	141
12	468	141
13	476	141
14	480	141
0	480	141

Iter	Nodes	Cost
0	38	312
0	60	301
1	81	295
2	104	293
3	131	293
4	146	293
5	201	293
6	240	293
7	261	293
8	295	293
9	330	293
10	375	293
11	401	293
0	401	253

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	29	150
0	48	142
1	63	141
2	81	141
3	100	141
4	128	141
5	178	141
6	263	141
7	371	141
8	414	141
9	432	141
10	446	141
11	459	141
12	468	141
13	476	141
14	480	141
0	480	141

Iter	Nodes	Cost
0	38	312
0	60	301
1	81	295
2	104	293
3	131	293
4	146	293
5	201	293
6	240	293
7	261	293
8	295	293
9	330	293
10	375	293
11	401	293
0	401	253

start0.0ms (0%)

analyze77.0ms (1.3%)

sample910.0ms (15.1%)

explain127.0ms (2.1%)

preprocess21.0ms (0.3%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify3.0ms (0%)

localize34.0ms (0.6%)

series17.0ms (0.3%)

simplify170.0ms (2.8%)

rewrite142.0ms (2.3%)

eval59.0ms (1%)

prune18.0ms (0.3%)

simplify19.0ms (0.3%)

localize88.0ms (1.5%)

series128.0ms (2.1%)

simplify214.0ms (3.6%)

rewrite179.0ms (3%)

eval418.0ms (6.9%)

prune72.0ms (1.2%)

simplify63.0ms (1%)

localize126.0ms (2.1%)

series193.0ms (3.2%)

simplify210.0ms (3.5%)

rewrite180.0ms (3%)

eval259.0ms (4.3%)

prune46.0ms (0.8%)

simplify14.0ms (0.2%)

localize123.0ms (2%)

series158.0ms (2.6%)

simplify209.0ms (3.5%)

rewrite183.0ms (3%)

eval232.0ms (3.8%)

prune40.0ms (0.7%)

regimes143.0ms (2.4%)

regimes125.0ms (2.1%)

regimes42.0ms (0.7%)

regimes41.0ms (0.7%)

regimes15.0ms (0.2%)

simplify27.0ms (0.5%)

soundness814.0ms (13.5%)

preprocess93.0ms (1.5%)

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	29	150
0	48	142
1	63	141
2	81	141
3	100	141
4	128	141
5	178	141
6	263	141
7	371	141
8	414	141
9	432	141
10	446	141
11	459	141
12	468	141
13	476	141
14	480	141
0	480	141

Iter	Nodes	Cost
0	38	312
0	60	301
1	81	295
2	104	293
3	131	293
4	146	293
5	201	293
6	240	293
7	261	293
8	295	293
9	330	293
10	375	293
11	401	293
0	401	253