Metrics for math.log10 on complex, real part

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze61.0ms (0.7%)

Memory

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

sample1.2s (13.6%)

Memory

-214.8MiB live, 1 690.5MiB allocated

Samples

933.0ms

8 256×

valid

Precisions

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

ival-log: 193.0ms (45.4% of total)

ival-hypot: 151.0ms (35.5% of total)

ival-div: 68.0ms (16% of total)

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

exact: 5.0ms (1.2% of total)

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

Bogosity

explain151.0ms (1.7%)

Memory

26.9MiB live, 222.2MiB allocated

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
112	-	2	(-1.8260355162018528e-224 1.6598346182392385e-162)	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	0	-	`(log.f64 #s(literal 10 binary64))`
0	-	0	-	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
0	-	0	-	`(*.f64 re re)`
0	-	0	-	`im`
0	-	0	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	0	-	`re`
0	-	0	-	`(*.f64 im im)`
0	-	0	-	`#s(literal 10 binary64)`
0	-	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	96	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	96
↳	`(*.f64 re re)`	overflow	53
↳	`(*.f64 im im)`	overflow	54
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	14	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	14
↳	`(*.f64 re re)`	underflow	76
↳	`(*.f64 im im)`	underflow	58

Confusion

	Predicted +	Predicted -
+	110	2
-	0	144

Precision

1.0

Recall

0.9821428571428571

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	110	0	2
-	0	0	144

Precision?

1.0

Recall?

0.9821428571428571

Freqs

test

number	freq
0	146
1	110

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

86.0ms

512×

valid

Compiler

Compiled 110 to 34 computations (69.1% saved)

Precisions

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

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

ival-log: 14.0ms (32.2% of total)

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

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

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

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

exact: 0.0ms (0% of total)

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

preprocess20.0ms (0.2%)

Memory

-5.4MiB live, 33.5MiB allocated

Algorithm

1×	egg-herbie

Rules

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

Iterations

Useful iterations: 0 (0.0ms)

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

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 (sqrt.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.7MiB live, 1.7MiB allocated

Alt Table

Click to see full alt table

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

7.4MiB live, 7.4MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(*.f64 re re)
cost-diff	0	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
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)))

Rules

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

Iterations

Useful iterations: 0 (0.0ms)

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

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

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

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

localize53.0ms (0.6%)

Memory

7.9MiB live, 46.5MiB allocated

Localize:

Found 4 expressions of interest:

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

Samples

45.0ms

256×

valid

Compiler

Compiled 49 to 12 computations (75.5% saved)

Precisions

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

ival-hypot: 26.0ms (69.3% of total)

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

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

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

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

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

exact: 0.0ms (0% of total)

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

series29.0ms (0.3%)

Memory

-13.0MiB live, 30.6MiB allocated

Counts

5 → 84

Calls

Call 1

Inputs
#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 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation:binary64>) () ())
#s(alt (.f64 re re) (patch (.f64 re re) #<representation:binary64>) () ())
#s(alt (log.f64 #s(literal 10 binary64)) (patch (log.f64 #s(literal 10 binary64)) #<representation:binary64>) () ())

Outputs
#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 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 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 (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 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 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 (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 (* -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 -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 (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 (* -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 (* -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
18.0ms	re	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* re re) (log 10))
3.0ms	re	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* re re) (log 10))
2.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* re re) (log 10))
1.0ms	im	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* re re) (log 10))
1.0ms	re	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* re re) (log 10))

simplify195.0ms (2.2%)

Memory

0.5MiB live, 313.4MiB allocated

Algorithm

1×	egg-herbie

Rules

16 860×	`lower-fma.f64`
16 860×	`lower-fma.f32`
5 980×	`lower-*.f64`
5 980×	`lower-*.f32`
2 506×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	263	1532
1	708	1488
2	2155	1470
3	7174	1438
0	8300	1348

Stop Event

1×	iter limit
1×	node limit

Counts

84 → 80

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

rewrite200.0ms (2.3%)

Memory

-1.5MiB live, 318.2MiB allocated

Rules

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

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	10	34
0	17	34
1	44	34
2	251	34
3	2046	34
0	8387	22

Stop Event

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

Counts

5 → 176

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 re re)
(log.f64 #s(literal 10 binary64))

Outputs
(*.f64 (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -1 binary64)) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))
(.f64 (.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) #s(literal 1/2 binary64)) (log.f64 (hypot.f64 im re)))
(.f64 (.f64 #s(literal 1 binary64) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64)))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -1/2 binary64)) (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -1/2 binary64)))
(*.f64 (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 1 binary64)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (pow.f64 (/.f64 #s(literal -1 binary64) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))))
(*.f64 #s(literal -1 binary64) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (/.f64 (/.f64 #s(literal 2 binary64) (log.f64 (hypot.f64 im re))) #s(literal 1 binary64)) #s(literal -1 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (pow.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 1 binary64)))
(*.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 #s(literal 10 binary64))))
(*.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))
(.f64 #s(literal 1/2 binary64) (.f64 (log.f64 (hypot.f64 im re)) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64))))
(*.f64 #s(literal 1/2 binary64) (/.f64 (log.f64 (hypot.f64 im re)) (log.f64 #s(literal 10 binary64))))
(*.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(*.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)))
(pow.f64 (exp.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))) #s(literal -1 binary64))
(pow.f64 (*.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -1/2 binary64)) #s(literal 2 binary64))
(pow.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))) #s(literal -1 binary64))
(pow.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))
(/.f64 (neg.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 1 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (neg.f64 (*.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))) #s(literal 1 binary64))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (*.f64 #s(literal 1 binary64) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal -1 binary64)))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal 1 binary64))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))))) (*.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 #s(literal 10 binary64))))
(/.f64 (-.f64 (.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 2 binary64)))
(/.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 1 binary64)) (log.f64 #s(literal 10 binary64)))
(/.f64 (*.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))) #s(literal 1 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (*.f64 #s(literal 1 binary64) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (neg.f64 (/.f64 #s(literal 2 binary64) (log.f64 (hypot.f64 im re)))))
(/.f64 #s(literal -1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal 2 binary64) (log.f64 (hypot.f64 im re))))
(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re)))))
(/.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 #s(literal 10 binary64)))
(neg.f64 (*.f64 #s(literal 1 binary64) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64)))))
(neg.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 (/.f64 (log.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 (log.f64 (sqrt.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))))) (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))))) (log.f64 #s(literal 10 binary64))))
(-.f64 (/.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64))) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))))
(-.f64 #s(literal 0 binary64) (/.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) (log.f64 #s(literal 1/10 binary64))))
(exp.f64 (*.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))) #s(literal -1 binary64)))
(*.f64 #s(literal 1/4 binary64) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 2 binary64))))
(*.f64 #s(literal -1 binary64) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))))
(*.f64 (log.f64 (hypot.f64 im re)) #s(literal 1/2 binary64))
(*.f64 #s(literal 1 binary64) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(*.f64 #s(literal 2 binary64) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))))
(.f64 #s(literal 1/2 binary64) (.f64 (log.f64 (hypot.f64 im re)) #s(literal 1 binary64)))
(*.f64 #s(literal 1/2 binary64) (log.f64 (hypot.f64 im re)))
(*.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))) #s(literal 1 binary64))
(/.f64 (+.f64 (pow.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))) #s(literal 3 binary64)) (pow.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))) #s(literal 3 binary64))) (fma.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))) (-.f64 (.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64)))) (.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64)))))))
(neg.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))))
(fma.f64 #s(literal 1/4 binary64) (log.f64 (hypot.f64 im re)) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))))
(fma.f64 (log.f64 (hypot.f64 im re)) #s(literal 1/4 binary64) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (log.f64 (pow.f64 (*.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1/2 binary64))))
(fma.f64 #s(literal 1/2 binary64) (log.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64)))) (log.f64 (pow.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (log.f64 (neg.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64)))))) (log.f64 (neg.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))))) (log.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (log.f64 (sqrt.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(-.f64 (log.f64 (sqrt.f64 (neg.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64)))))) (log.f64 (sqrt.f64 (neg.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))))
(-.f64 (log.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(-.f64 (log.f64 (sqrt.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))))) (log.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(-.f64 #s(literal 0 binary64) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))))
(+.f64 (log.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))) (log.f64 (pow.f64 (*.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1/2 binary64))))
(+.f64 (log.f64 (sqrt.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))))) (log.f64 (pow.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64))))
(+.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))))
(log.f64 (sqrt.f64 (hypot.f64 im re)))
(.f64 (sqrt.f64 (/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (-.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))) (sqrt.f64 (fma.f64 (.f64 im im) (hypot.f64 im re) (pow.f64 re #s(literal 4 binary64)))))
(.f64 (sqrt.f64 (/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (-.f64 (pow.f64 re #s(literal 8 binary64)) (pow.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) #s(literal 2 binary64))))) (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(.f64 (sqrt.f64 (/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (hypot.f64 (pow.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) #s(literal 3/2 binary64)) (pow.f64 re #s(literal 6 binary64))))) (sqrt.f64 (fma.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (-.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 re #s(literal 8 binary64)))))
(*.f64 (sqrt.f64 (/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))) (sqrt.f64 (hypot.f64 im re)))
(*.f64 (sqrt.f64 (/.f64 (hypot.f64 im re) (+.f64 im re))) (sqrt.f64 (+.f64 im re)))
(.f64 (pow.f64 (pow.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(.f64 (pow.f64 (pow.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) #s(literal 1/4 binary64)) #s(literal 2 binary64)) (pow.f64 (pow.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/4 binary64)) #s(literal 2 binary64)))
(.f64 (pow.f64 (/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (-.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (.f64 im im) (hypot.f64 im re) (pow.f64 re #s(literal 4 binary64)))))
(.f64 (pow.f64 (/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (-.f64 (pow.f64 re #s(literal 8 binary64)) (pow.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) #s(literal 2 binary64)))) #s(literal 1/2 binary64)) (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))))))
(.f64 (pow.f64 (/.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) (hypot.f64 (pow.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) #s(literal 3/2 binary64)) (pow.f64 re #s(literal 6 binary64)))) #s(literal 1/2 binary64)) (sqrt.f64 (fma.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (-.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) (pow.f64 re #s(literal 8 binary64)))))
(*.f64 (pow.f64 (/.f64 (hypot.f64 im re) (+.f64 im re)) #s(literal 1/2 binary64)) (sqrt.f64 (+.f64 im re)))
(*.f64 (pow.f64 (/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) #s(literal 1/2 binary64)) (sqrt.f64 (hypot.f64 im re)))
(*.f64 (pow.f64 #s(literal 1 binary64) #s(literal 1/2 binary64)) (sqrt.f64 (hypot.f64 im re)))
(.f64 (sqrt.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (sqrt.f64 (pow.f64 (.f64 (+.f64 im re) (-.f64 im re)) #s(literal -1 binary64))))
(.f64 (sqrt.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (pow.f64 (.f64 (+.f64 im re) (-.f64 im re)) #s(literal -1 binary64)) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))) (sqrt.f64 (pow.f64 (neg.f64 (.f64 (-.f64 re im) (+.f64 im re))) #s(literal -1 binary64))))
(.f64 (sqrt.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))) (pow.f64 (pow.f64 (neg.f64 (.f64 (-.f64 re im) (+.f64 im re))) #s(literal -1 binary64)) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (neg.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))))) (sqrt.f64 (pow.f64 (neg.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1 binary64))))
(.f64 (sqrt.f64 (neg.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))))) (pow.f64 (pow.f64 (neg.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))) #s(literal -1 binary64)) #s(literal 1/2 binary64)))
(.f64 (pow.f64 (.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1/2 binary64)) (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))
(.f64 (pow.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64)) (sqrt.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64)))))
(*.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64)) (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64)))
(.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (pow.f64 (.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1/2 binary64)))
(.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))) (sqrt.f64 (/.f64 (hypot.f64 im re) (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))) (sqrt.f64 (.f64 (hypot.f64 im re) (pow.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 binary64)))))
(.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (/.f64 (hypot.f64 im re) (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))) (pow.f64 (.f64 (hypot.f64 im re) (pow.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64)))) (pow.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1/2 binary64)))
(*.f64 #s(literal 1 binary64) (sqrt.f64 (hypot.f64 im re)))
(.f64 (sqrt.f64 (hypot.f64 im re)) (sqrt.f64 (/.f64 (.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(.f64 (sqrt.f64 (hypot.f64 im re)) (sqrt.f64 (.f64 (.f64 (-.f64 re im) (+.f64 im re)) (pow.f64 (.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1 binary64)))))
(.f64 (sqrt.f64 (hypot.f64 im re)) (pow.f64 (/.f64 (.f64 (-.f64 re im) (+.f64 im re)) (*.f64 (-.f64 re im) (+.f64 im re))) #s(literal 1/2 binary64)))
(.f64 (sqrt.f64 (hypot.f64 im re)) (pow.f64 (.f64 (.f64 (-.f64 re im) (+.f64 im re)) (pow.f64 (.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1 binary64))) #s(literal 1/2 binary64)))
(pow.f64 (exp.f64 #s(literal -1 binary64)) (log.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))))
(pow.f64 (exp.f64 #s(literal 1 binary64)) (log.f64 (sqrt.f64 (hypot.f64 im re))))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (*.f64 (log.f64 (hypot.f64 im re)) #s(literal 1 binary64)))
(pow.f64 (exp.f64 #s(literal 1/2 binary64)) (log.f64 (hypot.f64 im re)))
(pow.f64 (pow.f64 (hypot.f64 im re) #s(literal 2 binary64)) #s(literal 1/4 binary64))
(pow.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64)) #s(literal 2 binary64))
(pow.f64 (pow.f64 (hypot.f64 im re) #s(literal -1 binary64)) #s(literal -1/2 binary64))
(pow.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64)) #s(literal -1 binary64))
(pow.f64 (sqrt.f64 (hypot.f64 im re)) #s(literal 1 binary64))
(pow.f64 (hypot.f64 im re) #s(literal 1/2 binary64))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (neg.f64 (neg.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (neg.f64 (sqrt.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64)))))) (neg.f64 (neg.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))))
(/.f64 (neg.f64 (sqrt.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))))) (neg.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (neg.f64 (sqrt.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (neg.f64 (sqrt.f64 (neg.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64)))))) (neg.f64 (sqrt.f64 (neg.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))))
(/.f64 (sqrt.f64 (/.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))) (+.f64 im re))) (sqrt.f64 (-.f64 re im)))
(/.f64 (sqrt.f64 (.f64 (-.f64 (pow.f64 re #s(literal 8 binary64)) (pow.f64 im #s(literal 8 binary64))) (pow.f64 (.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1 binary64)))) (sqrt.f64 (hypot.f64 (.f64 im im) (.f64 re re))))
(/.f64 (sqrt.f64 (.f64 (-.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (pow.f64 (.f64 (-.f64 re im) (+.f64 im re)) #s(literal -1 binary64)))) (sqrt.f64 (+.f64 (hypot.f64 (pow.f64 (*.f64 im re) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 8 binary64)))))
(/.f64 (sqrt.f64 (.f64 (-.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) (pow.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 binary64)))) (sqrt.f64 (-.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64)))))
(/.f64 (sqrt.f64 (.f64 (hypot.f64 (pow.f64 im #s(literal 9 binary64)) (pow.f64 re #s(literal 9 binary64))) (pow.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) #s(literal -1 binary64)))) (sqrt.f64 (-.f64 (hypot.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (*.f64 im re) #s(literal 6 binary64)))))
(/.f64 (sqrt.f64 (.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))) #s(literal 1 binary64))) (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (-.f64 re im) (+.f64 im re))) #s(literal 2 binary64)) (pow.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (-.f64 re im) (+.f64 im re))) #s(literal 2 binary64)))) (sqrt.f64 (+.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (-.f64 re im) (+.f64 im re))) #s(literal 3 binary64)) (pow.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (-.f64 re im) (+.f64 im re))) #s(literal 3 binary64)))) (sqrt.f64 (+.f64 (pow.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (-.f64 re im) (+.f64 im re))) #s(literal 2 binary64)) (+.f64 (pow.f64 (/.f64 (pow.f64 im #s(literal 4 binary64)) (.f64 (-.f64 re im) (+.f64 im re))) #s(literal 2 binary64)) (.f64 (/.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (-.f64 re im) (+.f64 im re))) (/.f64 (pow.f64 im #s(literal 4 binary64)) (*.f64 (-.f64 re im) (+.f64 im re))))))))
(/.f64 (sqrt.f64 (neg.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))))) (sqrt.f64 (neg.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (sqrt.f64 (neg.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (sqrt.f64 (neg.f64 (neg.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64)))))) (sqrt.f64 (neg.f64 (neg.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))))
(/.f64 (sqrt.f64 (.f64 (-.f64 (pow.f64 re #s(literal 8 binary64)) (pow.f64 im #s(literal 8 binary64))) #s(literal 1 binary64))) (sqrt.f64 (.f64 (hypot.f64 (.f64 im im) (.f64 re re)) (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 (.f64 (-.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) #s(literal 1 binary64))) (sqrt.f64 (.f64 (+.f64 (hypot.f64 (pow.f64 (.f64 im re) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 8 binary64))) (.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 (.f64 (-.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64))) #s(literal 1 binary64))) (sqrt.f64 (.f64 (-.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(/.f64 (sqrt.f64 (.f64 (hypot.f64 (pow.f64 im #s(literal 9 binary64)) (pow.f64 re #s(literal 9 binary64))) #s(literal 1 binary64))) (sqrt.f64 (.f64 (-.f64 (hypot.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (.f64 im re) #s(literal 6 binary64))) (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(/.f64 (sqrt.f64 (-.f64 (.f64 (pow.f64 re #s(literal 4 binary64)) (.f64 (-.f64 re im) (+.f64 im re))) (.f64 (.f64 (-.f64 re im) (+.f64 im re)) (pow.f64 im #s(literal 4 binary64))))) (sqrt.f64 (pow.f64 (*.f64 (-.f64 re im) (+.f64 im re)) #s(literal 2 binary64))))
(/.f64 (sqrt.f64 #s(literal -1 binary64)) (sqrt.f64 (neg.f64 (pow.f64 (hypot.f64 im re) #s(literal -1 binary64)))))
(/.f64 (exp.f64 (log.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))))) (exp.f64 (log.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))))
(/.f64 (exp.f64 (log.f64 (sqrt.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64)))))) (exp.f64 (log.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))))
(/.f64 (neg.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))) (neg.f64 (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (neg.f64 (sqrt.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))))) (neg.f64 (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 8 binary64)) (pow.f64 im #s(literal 8 binary64)))) (sqrt.f64 (.f64 (.f64 (-.f64 re im) (+.f64 im re)) (hypot.f64 (.f64 im im) (.f64 re re)))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64)))) (sqrt.f64 (.f64 (.f64 (-.f64 re im) (+.f64 im re)) (+.f64 (hypot.f64 (pow.f64 (*.f64 im re) #s(literal 2 binary64)) (pow.f64 im #s(literal 4 binary64))) (pow.f64 re #s(literal 8 binary64))))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 12 binary64)) (pow.f64 im #s(literal 12 binary64)))) (sqrt.f64 (.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) (-.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))))))
(/.f64 (sqrt.f64 (hypot.f64 (pow.f64 im #s(literal 9 binary64)) (pow.f64 re #s(literal 9 binary64)))) (sqrt.f64 (.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))) (-.f64 (hypot.f64 (pow.f64 re #s(literal 6 binary64)) (pow.f64 im #s(literal 6 binary64))) (pow.f64 (*.f64 im re) #s(literal 6 binary64))))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64)))) (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))))
(/.f64 (sqrt.f64 (neg.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64))))) (sqrt.f64 (neg.f64 (*.f64 (-.f64 re im) (+.f64 im re)))))
(/.f64 (sqrt.f64 (neg.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64))))) (sqrt.f64 (neg.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64))))))
(/.f64 (sqrt.f64 (-.f64 (pow.f64 re #s(literal 4 binary64)) (pow.f64 im #s(literal 4 binary64)))) (sqrt.f64 (*.f64 (-.f64 re im) (+.f64 im re))))
(/.f64 (sqrt.f64 (hypot.f64 (pow.f64 im #s(literal 3 binary64)) (pow.f64 re #s(literal 3 binary64)))) (sqrt.f64 (+.f64 (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 (*.f64 im re) #s(literal 2 binary64))) (pow.f64 re #s(literal 4 binary64)))))
(/.f64 #s(literal -1 binary64) (neg.f64 (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (*.f64 (+.f64 im re) (-.f64 im re)) (-.f64 (pow.f64 im #s(literal 4 binary64)) (pow.f64 re #s(literal 4 binary64))))))
(/.f64 #s(literal 1 binary64) (sqrt.f64 (/.f64 (pow.f64 (hypot.f64 im re) #s(literal -1 binary64)) #s(literal 1 binary64))))
(/.f64 #s(literal 1 binary64) (pow.f64 (hypot.f64 im re) #s(literal -1/2 binary64)))
(sqrt.f64 (hypot.f64 im re))
(exp.f64 (*.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 2 binary64))) #s(literal 1/4 binary64)))
(exp.f64 (*.f64 (log.f64 (pow.f64 (hypot.f64 im re) #s(literal 1/4 binary64))) #s(literal 2 binary64)))
(exp.f64 (log.f64 (sqrt.f64 (hypot.f64 im re))))
(*.f64 re re)
(pow.f64 (exp.f64 #s(literal 2 binary64)) (log.f64 re))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(exp.f64 (.f64 (.f64 (log.f64 re) #s(literal 2 binary64)) #s(literal 1 binary64)))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(*.f64 #s(literal -1 binary64) (log.f64 #s(literal 1/10 binary64)))
(*.f64 #s(literal 1 binary64) (log.f64 #s(literal 10 binary64)))
(*.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(pow.f64 (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)) #s(literal -1 binary64))
(pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(/.f64 #s(literal -1 binary64) (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)))
(/.f64 #s(literal 1 binary64) (pow.f64 (log.f64 #s(literal 10 binary64)) #s(literal -1 binary64)))
(/.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64))
(/.f64 (log.f64 #s(literal 10 binary64)) #s(literal 1 binary64))
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(literal 1/10 binary64)))
(exp.f64 (neg.f64 (*.f64 (log.f64 (log.f64 #s(literal 10 binary64))) #s(literal -1 binary64))))
(log.f64 #s(literal 10 binary64))

eval60.0ms (0.7%)

Memory: 12.9MiB live, 88.5MiB allocated
Compiler: Compiled 5 355 to 1 014 computations (81.1% saved)

prune16.0ms (0.2%)

Memory

-13.7MiB live, 25.2MiB allocated

Pruning

6 alts after pruning (5 fresh and 1 done)

	Pruned	Kept	Total
New	251	5	256
Fresh	0	0	0
Picked	0	1	1
Done	0	0	0
Total	251	6	257

Accuracy

99.3%

Counts

257 → 6

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	57.4%	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	57.4%	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
▶	94.7%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) (log.f64 #s(literal 10 binary64)))
▶	98.9%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im) (log.f64 im))) (log.f64 #s(literal 10 binary64)))
▶	98.6%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
▶	98.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re) (/.f64 (/.f64 re im) im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))

Compiler

Compiled 142 to 116 computations (18.3% saved)

simplify23.0ms (0.3%)

Memory

7.0MiB live, 45.5MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score	Program
cost-diff	0	(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
cost-diff	0	(fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im) (log.f64 im))
cost-diff	0	#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im) (log.f64 im)))
cost-diff	0	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im) (log.f64 im))) (log.f64 #s(literal 10 binary64)))
cost-diff	0	(*.f64 re re)
cost-diff	0	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
cost-diff	0	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
cost-diff	0	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
cost-diff	0	(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
cost-diff	0	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
cost-diff	0	(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)))
cost-diff	0	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) (log.f64 #s(literal 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	(/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))
cost-diff	0	(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re)
cost-diff	0	(fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re) (/.f64 (/.f64 re im) im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
cost-diff	0	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re) (/.f64 (/.f64 re im) im) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))

Rules

282×	`lower-*.f32`
274×	`lower-*.f64`
144×	`lower-/.f32`
126×	`lower-/.f64`
116×	`associate-l`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	40	310
0	68	310
1	99	310
2	162	310
3	234	310
4	352	310
5	442	310
6	453	310
7	461	310
8	472	310
9	480	310
10	482	310
0	482	262

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

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

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

localize98.0ms (1.1%)

Memory

4.3MiB live, 287.7MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.00390625	(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
accuracy	0.0078125	(fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im) (log.f64 im))
accuracy	0.07810229561143622	#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im) (log.f64 im)))
accuracy	0.6361313476844203	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (*.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im) (log.f64 im))) (log.f64 #s(literal 10 binary64)))
accuracy	0	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
accuracy	0.6361313476844203	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
accuracy	1.0	(log.f64 #s(literal 1/10 binary64))
accuracy	25.949511791041736	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.12583867662814774	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))
accuracy	0.6361313476844203	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im))) (log.f64 #s(literal 10 binary64)))
accuracy	2.7461027656841663	(fma.f64 (/.f64 #s(literal 1/2 binary64) im) (*.f64 re re) im)
accuracy	0	(log.f64 im)
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.29199353671307365	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.6361313476844203	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
accuracy	0.12890625	(/.f64 (/.f64 re im) im)
accuracy	0.1484375	(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re)
accuracy	0.6400375976844203	(/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))
accuracy	1.0	(/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))

Samples

68.0ms

256×

valid

Compiler

Compiled 240 to 31 computations (87.1% saved)

Precisions

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

ival-log: 14.0ms (29% of total)

ival-div: 11.0ms (22.8% of total)

ival-mult: 10.0ms (20.7% of total)

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

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

const: 4.0ms (8.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)

series229.0ms (2.6%)

Memory

-28.7MiB live, 297.5MiB allocated

Counts

23 → 432

Calls

Call 1

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

Calls

6 calls:

Time	Variable		Point	Expression
65.0ms	im	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (* (/ 1/2 (log 10)) re) (/ 1/2 (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (log 10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ 1/2 im) (* re re)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (* (/ re im) 1/2) (/ (log im) (log 10)) (/ (/ re im) im) (log 1/10))
62.0ms	re	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (* (/ 1/2 (log 10)) re) (/ 1/2 (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (log 10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ 1/2 im) (* re re)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (* (/ re im) 1/2) (/ (log im) (log 10)) (/ (/ re im) im) (log 1/10))
28.0ms	im	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (* (/ 1/2 (log 10)) re) (/ 1/2 (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (log 10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ 1/2 im) (* re re)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (* (/ re im) 1/2) (/ (log im) (log 10)) (/ (/ re im) im) (log 1/10))
21.0ms	re	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (* (/ 1/2 (log 10)) re) (/ 1/2 (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (log 10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ 1/2 im) (* re re)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (* (/ re im) 1/2) (/ (log im) (log 10)) (/ (/ re im) im) (log 1/10))
18.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (* (/ 1/2 (log 10)) re) (/ 1/2 (log 10)) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (log im) (log 10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ 1/2 im) (* re re)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* re re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (* (/ re im) 1/2) (/ (log im) (log 10)) (/ (/ re im) im) (log 1/10))

simplify235.0ms (2.7%)

Memory

22.3MiB live, 325.5MiB allocated

Algorithm

1×	egg-herbie

Rules

14 854×	`lower-fma.f64`
14 854×	`lower-fma.f32`
4 912×	`lower-*.f64`
4 912×	`lower-*.f32`
4 136×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	385	7295
1	1019	7091
2	3059	7063
3	7650	7063
0	8259	6695

Stop Event

1×	iter limit
1×	node limit

Counts

432 → 421

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

rewrite265.0ms (3%)

Memory

21.8MiB live, 456.7MiB allocated

Rules

5 102×	`lower-/.f32`
5 084×	`lower-/.f64`
4 702×	`lower-*.f32`
4 694×	`lower-*.f64`
4 010×	`lower-fma.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	40	258
0	68	257
1	203	257
2	1434	252
0	8538	203

Stop Event

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

Counts

23 → 856

Calls

Call 1

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

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

eval205.0ms (2.3%)

Memory: 9.8MiB live, 374.9MiB allocated
Compiler: Compiled 31 978 to 3 811 computations (88.1% saved)

prune104.0ms (1.2%)

Memory

-26.7MiB live, 94.6MiB allocated

Pruning

20 alts after pruning (18 fresh and 2 done)

	Pruned	Kept	Total
New	1 355	18	1 373
Fresh	0	0	0
Picked	4	1	5
Done	0	1	1
Total	1 359	20	1 379

Accuracy

100.0%

Counts

1 379 → 20

Alt Table

Click to see full alt table

Status	Accuracy	Program
	98.6%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓	57.4%	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
▶	98.9%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 #s(literal 1/2 binary64) re) im))) (log.f64 #s(literal 10 binary64)))
▶	98.9%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	98.6%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
	55.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (/.f64 (fma.f64 (.f64 (log.f64 im) im) im (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	47.9%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (.f64 (+.f64 (/.f64 (/.f64 (log.f64 im) re) re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
	3.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re))) (log.f64 #s(literal 10 binary64)))
	98.6%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	98.6%	(.f64 #s(literal -1 binary64) (pow.f64 (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im))) #s(literal -1 binary64)))
	72.2%	(exp.f64 (.f64 (log.f64 (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ ( re re) (* im im)))) (log.f64 im)))) #s(literal -1 binary64)))
▶	98.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re) (/.f64 (/.f64 re im) im) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
	97.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (/.f64 re im) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re)) (log.f64 #s(literal 10 binary64)) (.f64 im (log.f64 im))) (.f64 im (log.f64 #s(literal 10 binary64)))))
	97.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (/.f64 re im) (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re)) (log.f64 #s(literal 1/10 binary64)) (.f64 im (neg.f64 (log.f64 im)))) (.f64 im (log.f64 #s(literal 1/10 binary64)))))
▶	55.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re) re) (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im im) (log.f64 im))) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))))
	98.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)) (.f64 (.f64 im (log.f64 #s(literal 10 binary64))) #s(literal 1 binary64))) (.f64 (.f64 im (log.f64 #s(literal 10 binary64))) (/.f64 (log.f64 #s(literal 10 binary64)) (log.f64 im)))))
	96.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re) (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im (log.f64 #s(literal 10 binary64))) (log.f64 im))) (.f64 (.f64 im (log.f64 #s(literal 10 binary64))) (log.f64 #s(literal 10 binary64)))))
	55.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 #s(literal 10 binary64))) (.f64 (.f64 re (/.f64 re (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))) (.f64 im im))))
▶	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 (*.f64 re re) im))))
	47.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (+.f64 (/.f64 (/.f64 (log.f64 im) re) (.f64 re (log.f64 #s(literal 10 binary64)))) (/.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) im)) im)) (.f64 re re))))

Compiler

Compiled 670 to 507 computations (24.3% saved)

simplify230.0ms (2.6%)

Memory

21.2MiB live, 170.9MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

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

Rules

5 104×	`lower-*.f32`
5 084×	`lower-*.f64`
3 920×	`lower-fma.f32`
3 912×	`lower-fma.f64`
2 742×	`lower-/.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	56	473
0	90	473
1	149	473
2	247	473
3	414	473
4	650	458
5	1102	458
6	2430	458
7	3786	458
8	6656	458
0	8416	417

Stop Event

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

Calls

Call 1

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

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

localize232.0ms (2.7%)

Memory

-29.0MiB live, 218.7MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.2579979092707751	(.f64 (.f64 im im) (log.f64 im))
accuracy	0.3958587890737681	(.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))
accuracy	1.0	(/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))
accuracy	27.245308449177355	(/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re) re) (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im im) (log.f64 im))) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))))
accuracy	0.1484375	(*.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re)
accuracy	0.6400375976844203	(/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))
accuracy	1.0	(/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64)))
accuracy	1.0	(log.f64 #s(literal 1/10 binary64))
accuracy	0	(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) im)))
accuracy	0.12583867662814774	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) im))
accuracy	0.6361313476844203	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
accuracy	1.0	(log.f64 #s(literal 1/10 binary64))
accuracy	0.65625	(*.f64 (log.f64 #s(literal 10 binary64)) im)
accuracy	4.119799476808545	(.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 (*.f64 re re) im))
accuracy	7.373368049626564	(/.f64 (*.f64 re re) im)
accuracy	61.79620338733623	#s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 (*.f64 re re) im)))
accuracy	0	(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 #s(literal 1/2 binary64) re) im)))
accuracy	0	(log.f64 #s(literal 10 binary64))
accuracy	0.12583867662814774	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 #s(literal 1/2 binary64) re) im))
accuracy	0.6361313476844203	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 #s(literal 1/2 binary64) re) im))) (log.f64 #s(literal 10 binary64)))

Samples

162.0ms

256×

valid

Compiler

Compiled 337 to 43 computations (87.2% saved)

Precisions

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

ival-log: 39.0ms (34.1% of total)

ival-mult: 37.0ms (32.3% of total)

ival-div: 23.0ms (20.1% of total)

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

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

const: 4.0ms (3.5% of total)

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

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

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

exact: 0.0ms (0% of total)

series245.0ms (2.8%)

Memory

40.3MiB live, 236.7MiB allocated

Counts

27 → 492

Calls

Call 1

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

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

Calls

6 calls:

Time	Variable		Point	Expression
54.0ms	im	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ re im) (* 1/2 re)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/ 1/2 (* (log 10) im)) (* (log 10) im) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (* re 1/2) (/ re im)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (neg (log im)) (log 1/10))) (* (/ 1/2 (log 10)) re) (/ 1/2 (log 10)) (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (* (* im im) (log 10))) (* (* (/ 1/2 (log 10)) re) re) (log 10) (/ (* re re) im) (* (/ 1/2 (* (log 10) im)) (/ (* re re) im)) (log 1/10) (/ (neg (log im)) (log 1/10)) (* (* im im) (log 10)) (* (* im im) (log im)))
51.0ms	im	@	inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ re im) (* 1/2 re)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/ 1/2 (* (log 10) im)) (* (log 10) im) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (* re 1/2) (/ re im)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (neg (log im)) (log 1/10))) (* (/ 1/2 (log 10)) re) (/ 1/2 (log 10)) (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (* (* im im) (log 10))) (* (* (/ 1/2 (log 10)) re) re) (log 10) (/ (* re re) im) (* (/ 1/2 (* (log 10) im)) (/ (* re re) im)) (log 1/10) (/ (neg (log im)) (log 1/10)) (* (* im im) (log 10)) (* (* im im) (log im)))
50.0ms	im	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ re im) (* 1/2 re)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/ 1/2 (* (log 10) im)) (* (log 10) im) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (* re 1/2) (/ re im)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (neg (log im)) (log 1/10))) (* (/ 1/2 (log 10)) re) (/ 1/2 (log 10)) (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (* (* im im) (log 10))) (* (* (/ 1/2 (log 10)) re) re) (log 10) (/ (* re re) im) (* (/ 1/2 (* (log 10) im)) (/ (* re re) im)) (log 1/10) (/ (neg (log im)) (log 1/10)) (* (* im im) (log 10)) (* (* im im) (log im)))
30.0ms	re	@	-inf	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ re im) (* 1/2 re)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/ 1/2 (* (log 10) im)) (* (log 10) im) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (* re 1/2) (/ re im)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (neg (log im)) (log 1/10))) (* (/ 1/2 (log 10)) re) (/ 1/2 (log 10)) (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (* (* im im) (log 10))) (* (* (/ 1/2 (log 10)) re) re) (log 10) (/ (* re re) im) (* (/ 1/2 (* (log 10) im)) (/ (* re re) im)) (log 1/10) (/ (neg (log im)) (log 1/10)) (* (* im im) (log 10)) (* (* im im) (log im)))
24.0ms	re	@	0	((/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ re im) (* 1/2 re)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/ 1/2 (* (log 10) im)) (* (log 10) im) (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (* re 1/2) (/ re im)) im) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (neg (log im)) (log 1/10))) (* (/ 1/2 (log 10)) re) (/ 1/2 (log 10)) (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/ (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (* (* im im) (log 10))) (* (* (/ 1/2 (log 10)) re) re) (log 10) (/ (* re re) im) (* (/ 1/2 (* (log 10) im)) (/ (* re re) im)) (log 1/10) (/ (neg (log im)) (log 1/10)) (* (* im im) (log 10)) (* (* im im) (log im)))

simplify378.0ms (4.3%)

Memory

-3.9MiB live, 262.1MiB allocated

Algorithm

1×	egg-herbie

Rules

16 378×	`lower-fma.f64`
16 378×	`lower-fma.f32`
5 532×	`lower-*.f64`
5 532×	`lower-*.f32`
3 760×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	401	8015
1	1085	7823
2	3316	7795
0	8297	7457

Stop Event

1×	iter limit
1×	node limit

Counts

492 → 478

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

rewrite362.0ms (4.1%)

Memory

7.8MiB live, 260.1MiB allocated

Rules

5 682×	`lower-fma.f32`
5 674×	`lower-fma.f64`
5 110×	`lower-/.f32`
5 094×	`lower-/.f64`
4 638×	`lower-*.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	56	398
0	90	397
1	293	392
2	1955	370
0	8403	334

Stop Event

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

Counts

27 → 1 124

Calls

Call 1

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

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

eval381.0ms (4.4%)

Memory: 16.9MiB live, 472.7MiB allocated
Compiler: Compiled 41 493 to 4 896 computations (88.2% saved)

prune146.0ms (1.7%)

Memory

-22.7MiB live, 308.4MiB allocated

Pruning

55 alts after pruning (51 fresh and 4 done)

	Pruned	Kept	Total
New	1 744	45	1 789
Fresh	7	6	13
Picked	3	2	5
Done	0	2	2
Total	1 754	55	1 809

Accuracy

100.0%

Counts

1 809 → 55

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	98.6%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓	57.4%	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
✓	98.9%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 #s(literal 1/2 binary64) re) im))) (log.f64 #s(literal 10 binary64)))
✓	98.9%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	98.6%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
	55.7%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (/.f64 (fma.f64 (.f64 (log.f64 im) im) im (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
	47.9%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (.f64 (+.f64 (/.f64 (/.f64 (log.f64 im) re) re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶	3.2%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re))) (log.f64 #s(literal 10 binary64)))
	98.6%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
▶	98.9%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 re im) im))) #s(literal -1 binary64))))
	98.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (fma.f64 (/.f64 (.f64 #s(literal -1/2 binary64) re) (.f64 (log.f64 #s(literal 1/10 binary64)) im)) (/.f64 re im) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
	93.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (/.f64 (.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re) im) (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 im) im)) (.f64 (log.f64 #s(literal 10 binary64)) im)))
	93.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (/.f64 (.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re) im) (log.f64 #s(literal 1/10 binary64)) (.f64 im (neg.f64 (log.f64 im)))) (.f64 (log.f64 #s(literal 1/10 binary64)) im)))
	55.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re) re) (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im im) (log.f64 im))) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im)))
	96.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re) (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im (log.f64 #s(literal 10 binary64))) (log.f64 im))) (.f64 (.f64 im (log.f64 #s(literal 10 binary64))) (log.f64 #s(literal 10 binary64)))))
	55.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (.f64 (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im)) (.f64 im im))) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))))
	55.6%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (.f64 (.f64 (log.f64 im) im) im)) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))))
	93.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (.f64 (fma.f64 (/.f64 (.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re) im) (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 im) im)) (pow.f64 (*.f64 (log.f64 #s(literal 10 binary64)) im) #s(literal -1 binary64))))
	55.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (/ (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (* (* im im) (log 10))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 #s(literal 10 binary64))) (.f64 (.f64 re (/.f64 re (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))) (.f64 im im))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (/ (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (* (* im im) (log 10))) (.f64 (/.f64 (.f64 re (/.f64 re (log.f64 #s(literal 10 binary64)))) im) (/.f64 #s(literal 1/2 binary64) im))))
	47.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (/ (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (* (* im im) (log 10))) (.f64 (+.f64 (/.f64 (/.f64 (log.f64 im) re) (.f64 re (log.f64 #s(literal 10 binary64)))) (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 im im))) (.f64 re re))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (/.f64 (.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re) im) im)))
▶	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im (.f64 re re)) im))))
	3.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (/.f64 re (neg.f64 im)) (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re)) (neg.f64 im))))
	3.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (/.f64 re im) re) (.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) #s(literal -2 binary64)))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re) (*.f64 im im))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (.f64 re re) #s(literal -1/2 binary64)) (.f64 im (.f64 (log.f64 #s(literal 1/10 binary64)) im)))))
▶	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) re) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))))
	3.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) #s(literal 1 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (.f64 im im) re)))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im) (.f64 #s(literal -1/2 binary64) (.f64 re re))))))
	3.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) #s(literal -2 binary64)) (*.f64 (/.f64 re im) re)))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (neg.f64 im) im) (.f64 (*.f64 (neg.f64 re) re) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))))))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re)))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 #s(literal -1/2 binary64) (.f64 (/.f64 im (.f64 re re)) (*.f64 (log.f64 #s(literal 1/10 binary64)) im)))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (/.f64 re im) (log.f64 #s(literal 10 binary64))) (/.f64 re (.f64 im #s(literal 2 binary64))))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (/.f64 re im) im) (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re))))
	3.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 (/.f64 re im) re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1/2 binary64) im))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 (neg.f64 re) re) (*.f64 im im)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 #s(literal 1/2 binary64) im))))
	3.0%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1/2 binary64) (*.f64 im im)))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 re #s(literal -1 binary64)) im) (/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 im re)))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) (*.f64 im #s(literal -1 binary64))) (/.f64 re (log.f64 #s(literal 1/10 binary64))))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) im) (/.f64 re (log.f64 #s(literal 10 binary64))))))
	3.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 #s(literal 1/2 binary64) re) (.f64 (.f64 im im) #s(literal -1 binary64))) (/.f64 re (log.f64 #s(literal 1/10 binary64))))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) im))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 re im) (/.f64 (/.f64 re im) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64))))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (*.f64 (/.f64 #s(literal -1/2 binary64) (/.f64 im re)) (/.f64 (/.f64 re (log.f64 #s(literal 1/10 binary64))) im))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 #s(literal -1/2 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) im)) (/.f64 (*.f64 re re) im))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (.f64 (/.f64 (/.f64 re im) im) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))) re)))
	3.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (*.f64 im im) re))))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) #s(literal -1 binary64)) (/.f64 (/.f64 re im) (.f64 (log.f64 #s(literal 1/10 binary64)) im)))))
	3.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) #s(literal -1 binary64)) (/.f64 re (.f64 im (*.f64 (log.f64 #s(literal 1/10 binary64)) im))))))
	3.0%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (/.f64 #s(literal 1 binary64) (.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) im)))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 re (.f64 (/.f64 re im) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) im))))))

Compiler

Compiled 1 719 to 1 402 computations (18.4% saved)

simplify120.0ms (1.4%)

Memory

-8.7MiB live, 70.4MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score
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	(/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))
cost-diff	0	(/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im (.f64 re re)) im))
cost-diff	0	#s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im (.f64 re re)) im)))
cost-diff	0	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im (.f64 re re)) im))))
cost-diff	0	(.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re)
cost-diff	0	#s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re))
cost-diff	0	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re)))
cost-diff	0	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re))) (log.f64 #s(literal 10 binary64)))
cost-diff	0	(*.f64 #s(literal 1/2 binary64) re)
cost-diff	0	(.f64 (.f64 #s(literal 1/2 binary64) re) re)
cost-diff	0	#s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) re) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im)))
cost-diff	0	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) re) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))))
cost-diff	0	(log.f64 #s(literal 1/10 binary64))
cost-diff	0	(/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 re im) im))) #s(literal -1 binary64)))
cost-diff	192	(.f64 (log.f64 #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 re im) im))) #s(literal -1 binary64))
cost-diff	704	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 re im) im))) #s(literal -1 binary64))))

Rules

1 510×	`lower-*.f32`
1 490×	`lower-*.f64`
1 058×	`times-frac`
748×	`lower-fma.f32`
746×	`lower-fma.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	60	514
0	88	514
1	148	511
2	287	509
3	485	509
4	646	509
5	849	509
6	1048	509
7	1316	509
8	1832	509
9	2241	509
10	2416	509
11	2649	509
12	2665	509
13	2665	509
14	2785	509
15	2991	505
16	3006	497
17	3021	497
18	3045	497
19	3045	497
20	3045	497
21	3045	497
0	3045	442

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

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

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

localize131.0ms (1.5%)

Memory

24.3MiB live, 257.0MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0	(log.f64 im)
accuracy	0.29199353671307365	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
accuracy	0.6361313476844203	(/.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	1.0	(log.f64 #s(literal 1/10 binary64))
accuracy	4.727599348955559	(.f64 (/.f64 im (.f64 re re)) im)
accuracy	6.854655630023458	(/.f64 im (*.f64 re re))
accuracy	61.79620338733623	#s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im (.f64 re re)) im)))
accuracy	0.6709854839525525	(/.f64 #s(literal 1/2 binary64) (*.f64 im im))
accuracy	1.7152991673177738	(.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re)
accuracy	7.600173476384934	(.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re)
accuracy	61.79760367956836	#s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re))
accuracy	0.1484375	(.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im)
accuracy	0.65625	(*.f64 (log.f64 #s(literal 10 binary64)) im)
accuracy	14.656177955980356	(/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) re) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))
accuracy	61.79620338733623	#s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) re) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im)))
accuracy	0.12583867662814774	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 re im) im))
accuracy	0.3046875	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 re im) im))) #s(literal -1 binary64))))
accuracy	0.5947838379159782	(/.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 (log.f64 #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 #s(literal 1/2 binary64) re) (/.f64 re im) im))) #s(literal -1 binary64)))
accuracy	1.0	(log.f64 #s(literal 1/10 binary64))

Samples

93.0ms

256×

valid

Compiler

Compiled 317 to 47 computations (85.2% saved)

Precisions

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

ival-div: 23.0ms (33.1% of total)

ival-mult: 22.0ms (31.6% of total)

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

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

const: 4.0ms (5.7% of total)

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

exact: 1.0ms (1.4% of total)

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

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

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

series352.0ms (4%)

Memory

-26.2MiB live, 341.3MiB allocated

Counts

28 → 552

Calls

Call 1

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

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

Calls

6 calls:

Time	Variable		Point	Expression
105.0ms	im	@	0	((/ 1 (/ (log 1/10) (* (log (sqrt (+ (* re re) (* im im)))) -1))) (* (log (sqrt (+ (* re re) (* im im)))) -1) (/ (log 1/10) (* (log (sqrt (+ (* re re) (* im im)))) -1)) (log 1/10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (* (* 1/2 re) re) (* 1/2 re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (* (/ 1/2 (* im im)) re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/ (/ -1/2 (log 1/10)) (* (/ im (* re re)) im)) (/ -1/2 (log 1/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) (sqrt (+ (* re re) (* im im))) (/ (* (* 1/2 re) re) (* (* (log 10) im) im)) (* (log 10) im) (* (* (log 10) im) im) (* (* (/ 1/2 (* im im)) re) re) (/ 1/2 (* im im)) (/ im (* re re)) (* (/ im (* re re)) im))
50.0ms	re	@	inf	((/ 1 (/ (log 1/10) (* (log (sqrt (+ (* re re) (* im im)))) -1))) (* (log (sqrt (+ (* re re) (* im im)))) -1) (/ (log 1/10) (* (log (sqrt (+ (* re re) (* im im)))) -1)) (log 1/10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (* (* 1/2 re) re) (* 1/2 re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (* (/ 1/2 (* im im)) re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/ (/ -1/2 (log 1/10)) (* (/ im (* re re)) im)) (/ -1/2 (log 1/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) (sqrt (+ (* re re) (* im im))) (/ (* (* 1/2 re) re) (* (* (log 10) im) im)) (* (log 10) im) (* (* (log 10) im) im) (* (* (/ 1/2 (* im im)) re) re) (/ 1/2 (* im im)) (/ im (* re re)) (* (/ im (* re re)) im))
28.0ms	im	@	inf	((/ 1 (/ (log 1/10) (* (log (sqrt (+ (* re re) (* im im)))) -1))) (* (log (sqrt (+ (* re re) (* im im)))) -1) (/ (log 1/10) (* (log (sqrt (+ (* re re) (* im im)))) -1)) (log 1/10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (* (* 1/2 re) re) (* 1/2 re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (* (/ 1/2 (* im im)) re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/ (/ -1/2 (log 1/10)) (* (/ im (* re re)) im)) (/ -1/2 (log 1/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) (sqrt (+ (* re re) (* im im))) (/ (* (* 1/2 re) re) (* (* (log 10) im) im)) (* (log 10) im) (* (* (log 10) im) im) (* (* (/ 1/2 (* im im)) re) re) (/ 1/2 (* im im)) (/ im (* re re)) (* (/ im (* re re)) im))
26.0ms	re	@	0	((/ 1 (/ (log 1/10) (* (log (sqrt (+ (* re re) (* im im)))) -1))) (* (log (sqrt (+ (* re re) (* im im)))) -1) (/ (log 1/10) (* (log (sqrt (+ (* re re) (* im im)))) -1)) (log 1/10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (* (* 1/2 re) re) (* 1/2 re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (* (/ 1/2 (* im im)) re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/ (/ -1/2 (log 1/10)) (* (/ im (* re re)) im)) (/ -1/2 (log 1/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) (sqrt (+ (* re re) (* im im))) (/ (* (* 1/2 re) re) (* (* (log 10) im) im)) (* (log 10) im) (* (* (log 10) im) im) (* (* (/ 1/2 (* im im)) re) re) (/ 1/2 (* im im)) (/ im (* re re)) (* (/ im (* re re)) im))
24.0ms	im	@	-inf	((/ 1 (/ (log 1/10) (* (log (sqrt (+ (* re re) (* im im)))) -1))) (* (log (sqrt (+ (* re re) (* im im)))) -1) (/ (log 1/10) (* (log (sqrt (+ (* re re) (* im im)))) -1)) (log 1/10) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (* (* 1/2 re) re) (* 1/2 re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (* (/ 1/2 (* im im)) re) (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/ (/ -1/2 (log 1/10)) (* (/ im (* re re)) im)) (/ -1/2 (log 1/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) (sqrt (+ (* re re) (* im im))) (/ (* (* 1/2 re) re) (* (* (log 10) im) im)) (* (log 10) im) (* (* (log 10) im) im) (* (* (/ 1/2 (* im im)) re) re) (/ 1/2 (* im im)) (/ im (* re re)) (* (/ im (* re re)) im))

simplify215.0ms (2.5%)

Memory

33.3MiB live, 307.5MiB allocated

Algorithm

1×	egg-herbie

Rules

10 790×	`lower-fma.f64`
10 790×	`lower-fma.f32`
6 122×	`lower-*.f64`
6 122×	`lower-*.f32`
3 370×	`lower-+.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	665	9539
1	1979	9347
2	7094	9343
0	8217	8993

Stop Event

1×	iter limit
1×	node limit

Counts

552 → 548

Calls

Call 1

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

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

rewrite251.0ms (2.9%)

Memory

-7.7MiB live, 306.7MiB allocated

Rules

5 334×	`lower-*.f32`
5 314×	`lower-*.f64`
4 978×	`lower-/.f32`
4 958×	`lower-/.f64`
3 444×	`lower-fma.f32`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	60	448
0	88	448
1	283	442
2	1861	406
0	8923	355

Stop Event

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

Counts

28 → 462

Calls

Call 1

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

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

eval154.0ms (1.8%)

Memory: 19.2MiB live, 255.5MiB allocated
Compiler: Compiled 18 989 to 2 288 computations (88% saved)

prune145.0ms (1.7%)

Memory

-36.4MiB live, 301.1MiB allocated

Pruning

55 alts after pruning (48 fresh and 7 done)

	Pruned	Kept	Total
New	1 018	14	1 032
Fresh	12	34	46
Picked	2	3	5
Done	0	4	4
Total	1 032	55	1 087

Accuracy

100.0%

Counts

1 087 → 55

Alt Table

Click to see full alt table

Status	Accuracy	Program
	98.9%	(/.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (/.f64 #s(literal -1 binary64) (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)))))
✓	98.6%	(/.f64 (neg.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓	57.4%	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
✓	98.9%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 #s(literal 1/2 binary64) re) im))) (log.f64 #s(literal 10 binary64)))
✓	98.9%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 re #s(literal 1/2 binary64)) (/.f64 re im) im))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
✓	98.6%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im)) (log.f64 #s(literal 10 binary64)))
	3.4%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (.f64 (/.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) im) re))) (log.f64 #s(literal 10 binary64)))
	47.9%	(/.f64 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ re im) 1/2) (/ re im)) (log im)) (.f64 (+.f64 (/.f64 (/.f64 (log.f64 im) re) re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re)))) (log.f64 #s(literal 10 binary64)))
	98.6%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 10 binary64)) #s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))))
	98.6%	(/.f64 #s(literal 1 binary64) (/.f64 (log.f64 #s(literal 1/10 binary64)) #s(approx (* (log (sqrt (+ (* re re) (* im im)))) -1) (neg.f64 (log.f64 im)))))
	98.8%	(/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)))) (log.f64 #s(literal 1/10 binary64))))
	98.9%	(/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (pow.f64 (.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im))) #s(literal 1 binary64)) #s(literal -1 binary64))))
	98.9%	(.f64 (pow.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -1 binary64)) (pow.f64 (/.f64 (/.f64 #s(literal -1 binary64) (log.f64 #s(approx (sqrt (+ ( re re) (* im im))) (fma.f64 (*.f64 (/.f64 re im) re) #s(literal 1/2 binary64) im)))) #s(literal 1 binary64)) #s(literal -1 binary64)))
	98.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (neg (log 1/10))) (fma.f64 (/.f64 (.f64 #s(literal -1/2 binary64) re) (.f64 (log.f64 #s(literal 1/10 binary64)) im)) (/.f64 re im) (/.f64 (neg.f64 (log.f64 im)) (log.f64 #s(literal 1/10 binary64)))))
	93.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (/.f64 (.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re) im) (log.f64 #s(literal 10 binary64)) (.f64 (log.f64 im) im)) (.f64 (log.f64 #s(literal 10 binary64)) im)))
	55.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) re) re) (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im im) (log.f64 im))) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im)))
	96.9%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (fma.f64 (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) re) re) (log.f64 #s(literal 10 binary64)) (.f64 (.f64 im (log.f64 #s(literal 10 binary64))) (log.f64 im))) (.f64 (.f64 im (log.f64 #s(literal 10 binary64))) (log.f64 #s(literal 10 binary64)))))
	55.3%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (.f64 (fma.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) re) re (log.f64 im)) (.f64 im im))) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))))
	55.6%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (.f64 (.f64 (log.f64 im) im) im)) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 #s(approx (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (.f64 (.f64 re re) #s(literal 1/2 binary64))) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64)))))
	55.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (/ (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (* (* im im) (log 10))) (/.f64 (fma.f64 (.f64 (log.f64 im) im) (/.f64 im (log.f64 #s(literal 10 binary64))) (.f64 (.f64 re (/.f64 re (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64))) (.f64 im im))))
	47.8%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (/ (+ (* (* (* (/ 1/2 (log 10)) re) re) (log 10)) (* (* im im) (log im))) (* (* im im) (log 10))) (.f64 (+.f64 (/.f64 (/.f64 (log.f64 im) re) (.f64 re (log.f64 #s(literal 10 binary64)))) (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 im im))) (.f64 re re))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (/.f64 (.f64 (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re) im) im)))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (/.f64 #s(literal 1/2 binary64) (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 im (.f64 re re)) im))))
✓	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 (/.f64 im (.f64 re re)) im))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (*.f64 (/.f64 im re) (/.f64 im re)))))
	3.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (/.f64 (neg.f64 re) im) (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re)) (neg.f64 im))))
	3.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (/.f64 re im) re) (.f64 (*.f64 (log.f64 #s(literal 1/10 binary64)) im) #s(literal -2 binary64)))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (.f64 re re) #s(literal -1/2 binary64)) (.f64 im (.f64 (log.f64 #s(literal 1/10 binary64)) im)))))
✓	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) re) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) #s(literal 1 binary64)) (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) (/.f64 im re)))))
	3.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) #s(literal 1 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (.f64 im im) re)))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (.f64 (log.f64 #s(literal 1/10 binary64)) (.f64 im im)))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) im) (.f64 #s(literal -1/2 binary64) (.f64 re re))))))
	3.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 (.f64 (log.f64 #s(literal 1/10 binary64)) im) #s(literal -2 binary64)) (*.f64 (/.f64 re im) re)))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re) re)))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (/.f64 #s(literal -1/2 binary64) (.f64 (/.f64 im (.f64 re re)) (*.f64 (log.f64 #s(literal 1/10 binary64)) im)))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (/.f64 re im) (log.f64 #s(literal 10 binary64))) (/.f64 re (.f64 im #s(literal 2 binary64))))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (/.f64 re im) im) (.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) re))))
	3.0%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64))) (.f64 im im)) (*.f64 re re))))
	3.5%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 (/.f64 re im) re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1/2 binary64) im))))
	3.1%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 (neg.f64 re) re) (*.f64 im im)) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 re re) (*.f64 (log.f64 #s(literal 10 binary64)) im)) (/.f64 #s(literal 1/2 binary64) im))))
	3.0%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))) (/.f64 #s(literal -1/2 binary64) (*.f64 im im)))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (.f64 re #s(literal -1 binary64)) im) (/.f64 (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 10 binary64))) (/.f64 im re)))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 (neg.f64 (/.f64 #s(literal 1/2 binary64) im)) (log.f64 #s(literal 1/10 binary64))) (/.f64 (.f64 re re) im))))
	3.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 re (.f64 (.f64 (log.f64 #s(literal 10 binary64)) im) im)) (.f64 #s(literal 1/2 binary64) re))))
	3.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 re (log.f64 #s(literal 10 binary64))) (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 re im) (/.f64 (/.f64 re im) (.f64 (log.f64 #s(literal 1/10 binary64)) #s(literal -2 binary64))))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (/.f64 #s(literal -1/2 binary64) (.f64 (log.f64 #s(literal 1/10 binary64)) im)) (/.f64 (*.f64 re re) im))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (.f64 (/.f64 (/.f64 re im) im) (/.f64 #s(literal -1/2 binary64) (log.f64 #s(literal 1/10 binary64)))) re)))
	3.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) #s(literal 1 binary64)) (/.f64 #s(literal 1 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (/.f64 (*.f64 im im) re))))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) #s(literal -1 binary64)) (/.f64 (/.f64 re im) (.f64 (log.f64 #s(literal 1/10 binary64)) im)))))
	3.2%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) #s(literal -1 binary64)) (/.f64 re (.f64 im (*.f64 (log.f64 #s(literal 1/10 binary64)) im))))))
	3.4%	#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(approx (+ (* (* (/ 1/2 (log 10)) re) (/ (/ re im) im)) (/ (log im) (log 10))) (.f64 re (.f64 (/.f64 re im) (/.f64 #s(literal 1/2 binary64) (*.f64 (log.f64 #s(literal 10 binary64)) im))))))

Compiler

Compiled 2 214 to 1 104 computations (50.1% saved)

regimes194.0ms (2.2%)

Memory

22.0MiB live, 407.0MiB allocated

Counts

83 → 1

Calls

Call 1

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

Outputs

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

Calls

8 calls:

28.0ms	im
25.0ms	(+.f64 (.f64 re re) (.f64 im im))
24.0ms	re
23.0ms	(*.f64 im im)
23.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))

Results

Accuracy	Segments	Branch
98.9%	1	`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 re re)`
98.9%	1	`(*.f64 im im)`

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes193.0ms (2.2%)

Memory

-19.5MiB live, 342.0MiB allocated

Counts

59 → 1

Calls

Call 1

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

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

Calls

8 calls:

62.0ms	im
23.0ms	(*.f64 re re)
18.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
18.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
18.0ms	(+.f64 (.f64 re re) (.f64 im im))

Results

Accuracy	Segments	Branch
98.9%	1	`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 re re)`
98.9%	1	`(*.f64 im im)`

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes124.0ms (1.4%)

Memory

30.7MiB live, 229.0MiB allocated

Counts

52 → 1

Calls

Call 1

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

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

Calls

8 calls:

17.0ms	(+.f64 (.f64 re re) (.f64 im im))
16.0ms	re
15.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
15.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
15.0ms	im

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes120.0ms (1.4%)

Memory

-2.6MiB live, 235.9MiB allocated

Counts

48 → 1

Calls

Call 1

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

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

Calls

8 calls:

17.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
16.0ms	re
16.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
14.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
14.0ms	im

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes129.0ms (1.5%)

Memory

-15.1MiB live, 263.1MiB allocated

Counts

46 → 1

Calls

Call 1

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

Outputs

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

Calls

8 calls:

18.0ms	(*.f64 re re)
17.0ms	im
16.0ms	(*.f64 im im)
16.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
16.0ms	(+.f64 (.f64 re re) (.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)

regimes46.0ms (0.5%)

Memory

-5.5MiB live, 115.5MiB allocated

Counts

16 → 1

Calls

Call 1

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

Outputs

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

Calls

8 calls:

8.0ms	re
6.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
6.0ms	(+.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)))

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes26.0ms (0.3%)

Memory

25.1MiB live, 63.9MiB allocated

Counts

8 → 1

Calls

Call 1

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

Outputs

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes67.0ms (0.8%)

Memory

-29.0MiB live, 50.2MiB allocated

Accuracy

Total -0.1b remaining (-0.2%)

Threshold costs -0.1b (-0.2%)

Counts

7 → 1

Calls

Call 1

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

Outputs

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

Calls

8 calls:

29.0ms	re
19.0ms	(*.f64 re re)
3.0ms	(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))
3.0ms	im
3.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

simplify35.0ms (0.4%)

Memory

32.7MiB live, 76.5MiB allocated

Algorithm

1×	egg-herbie

Rules

30×	`-commutative-binary64-.f64`
10×	`neg-sub0-binary64--.f64-neg.f64`
10×	`sub-neg-binary64-neg.f64-+.f64--.f64`
8×	`+-commutative-binary64-+.f64`
8×	`neg-mul-1-binary64-*.f64-neg.f64`

Iterations

Useful iterations: 6 (0.0ms)

Iter	Nodes	Cost
0	66	254
1	80	253
2	81	253
3	84	253
4	91	253
5	100	253
6	107	252
7	113	252

Stop Event

1×

saturated

Calls

Call 1

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

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

soundness1.2s (13.5%)

Memory

0.5MiB live, 994.4MiB allocated

Rules

16 860×	`lower-fma.f64`
16 860×	`lower-fma.f32`
14 854×	`lower-fma.f64`
14 854×	`lower-fma.f32`
5 980×	`lower-*.f64`

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	385	7295
1	1019	7091
2	3059	7063
3	7650	7063
0	8259	6695
0	60	448
0	88	448
1	283	442
2	1861	406
0	8923	355
0	56	398
0	90	397
1	293	392
2	1955	370
0	8403	334
0	40	258
0	68	257
1	203	257
2	1434	252
0	8538	203
0	263	1532
1	708	1488
2	2155	1470
3	7174	1438
0	8300	1348

Stop Event

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

Compiler

Compiled 323 to 241 computations (25.4% saved)

preprocess149.0ms (1.7%)

Memory: -16.4MiB live, 343.7MiB allocated
Compiler: Compiled 670 to 510 computations (23.9% 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	8

Iter	Nodes	Cost
0	40	310
0	68	310
1	99	310
2	162	310
3	234	310
4	352	310
5	442	310
6	453	310
7	461	310
8	472	310
9	480	310
10	482	310
0	482	262

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	8

Iter	Nodes	Cost
0	40	310
0	68	310
1	99	310
2	162	310
3	234	310
4	352	310
5	442	310
6	453	310
7	461	310
8	472	310
9	480	310
10	482	310
0	482	262

start0.0ms (0%)

analyze61.0ms (0.7%)

sample1.2s (13.6%)

explain151.0ms (1.7%)

preprocess20.0ms (0.2%)

eval0.0ms (0%)

prune1.0ms (0%)

simplify3.0ms (0%)

localize53.0ms (0.6%)

series29.0ms (0.3%)

simplify195.0ms (2.2%)

rewrite200.0ms (2.3%)

eval60.0ms (0.7%)

prune16.0ms (0.2%)

simplify23.0ms (0.3%)

localize98.0ms (1.1%)

series229.0ms (2.6%)

simplify235.0ms (2.7%)

rewrite265.0ms (3%)

eval205.0ms (2.3%)

prune104.0ms (1.2%)

simplify230.0ms (2.6%)

localize232.0ms (2.7%)

series245.0ms (2.8%)

simplify378.0ms (4.3%)

rewrite362.0ms (4.1%)

eval381.0ms (4.4%)

prune146.0ms (1.7%)

simplify120.0ms (1.4%)

localize131.0ms (1.5%)

series352.0ms (4%)

simplify215.0ms (2.5%)

rewrite251.0ms (2.9%)

eval154.0ms (1.8%)

prune145.0ms (1.7%)

regimes194.0ms (2.2%)

regimes193.0ms (2.2%)

regimes124.0ms (1.4%)

regimes120.0ms (1.4%)

regimes129.0ms (1.5%)

regimes46.0ms (0.5%)

regimes26.0ms (0.3%)

regimes67.0ms (0.8%)

simplify35.0ms (0.4%)

soundness1.2s (13.5%)

preprocess149.0ms (1.7%)

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	8

Iter	Nodes	Cost
0	40	310
0	68	310
1	99	310
2	162	310
3	234	310
4	352	310
5	442	310
6	453	310
7	461	310
8	472	310
9	480	310
10	482	310
0	482	262