Metrics for math.log/1 on complex, real part

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze46.0ms (0.7%)

Memory

20.6MiB live, 96.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 11 to 6 computations (45.5% saved)

sample938.0ms (13.4%)

Memory

19.3MiB live, 1 092.7MiB allocated

Samples

650.0ms

8 256×

valid

Precisions

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

ival-log: 192.0ms (53.2% of total)

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

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

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

Bogosity

explain154.0ms (2.2%)

Memory

1.5MiB live, 155.9MiB allocated

FPErrors

Click to see full error table

Ground Truth	Example	Example	Subexpression
131	-	-	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	-	`(*.f64 re re)`
0	-	-	`re`
0	-	-	`(*.f64 im im)`
0	-	-	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
0	-	-	`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	111	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	111
↳	`(*.f64 re re)`	overflow	73
↳	`(*.f64 im im)`	overflow	56
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	20	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	20
↳	`(*.f64 re re)`	underflow	54
↳	`(*.f64 im im)`	underflow	69

Confusion

	Predicted +	Predicted -
+	131	0
-	0	125

Precision

1.0

Recall

1.0

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	131	0	0
-	0	0	125

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	125
1	131

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

67.0ms

512×

valid

Compiler

Compiled 77 to 25 computations (67.5% saved)

Precisions

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

ival-hypot: 13.0ms (44.5% of total)

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

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

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

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

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

preprocess18.0ms (0.3%)

Memory

-9.7MiB live, 27.1MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	19	47
1	38	47
2	80	47
3	148	47
4	207	47
5	220	47
6	222	47
0	7	9
0	12	9
1	13	9
0	13	4

Stop Event

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

Calls

Call 1

Inputs
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))

Outputs
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(log.f64 (hypot.f64 im re))

Symmetry

(abs im)

(abs re)

(sort re im)

Compiler

Compiled 9 to 7 computations (22.2% saved)

eval0.0ms (0%)

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

prune0.0ms (0%)

Memory

1.3MiB live, 1.3MiB allocated

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	50.4%	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))

Compiler

Compiled 9 to 7 computations (22.2% saved)

simplify3.0ms (0%)

Memory

4.8MiB live, 4.8MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 4 expressions of interest:

New	Metric	Score
cost-diff	0	(*.f64 im im)
cost-diff	0	(*.f64 re re)
cost-diff	0	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
cost-diff	128	(+.f64 (.f64 re re) (.f64 im im))

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	7	32
0	12	32
1	13	32
0	13	21

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

Inputs
(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

Outputs
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(log.f64 (hypot.f64 im re))
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
(hypot.f64 im re)
(+.f64 (.f64 re re) (.f64 im im))
(fma.f64 im im (*.f64 re re))
(*.f64 re re)
re
(*.f64 im im)
im

localize42.0ms (0.6%)

Memory

-36.8MiB live, 37.4MiB allocated

Localize:

Found 4 expressions of interest:

New	Metric	Score
accuracy	0	(*.f64 im im)
accuracy	0	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
accuracy	0.0078125	(+.f64 (.f64 re re) (.f64 im im))
accuracy	30.37400735753213	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Samples

35.0ms

256×

valid

Compiler

Compiled 34 to 9 computations (73.5% saved)

Precisions

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

ival-mult: 19.0ms (67.1% of total)

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

ival-log: 3.0ms (10.6% of total)

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

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

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

series29.0ms (0.4%)

Memory

-17.1MiB live, 20.5MiB allocated

Counts

5 → 96

Calls

Call 1

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

Outputs
#s(alt (pow im 2) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2)))))) (taylor 0 re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt im (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* 1/2 (/ (pow re 2) im))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ im (* (pow re 2) (+ (* (pow re 2) (- (* 1/16 (/ (pow re 2) (pow im 5))) (* 1/8 (/ 1 (pow im 3))))) (* 1/2 (/ 1 im))))) (taylor 0 re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 re))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt re (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 re))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (patch (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor -inf re) (#s(alt (.f64 re re) (patch (.f64 re re) #<representation binary64>) () ())) ())
#s(alt (* -1 re) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2)))))))) (taylor -inf re) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow re 2) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (+ (pow im 2) (pow re 2)) (taylor 0 im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (log re) (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 (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt re (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* 1/2 (/ (pow im 2) re))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (+ re (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (pow re 5))) (* 1/8 (/ 1 (pow re 3))))) (* 1/2 (/ 1 re))))) (taylor 0 im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (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 (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt im (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))) (taylor inf im) (#s(alt (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) (patch (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2)))) (taylor -inf im) (#s(alt (+.f64 (.f64 re re) (.f64 im im)) (patch (+.f64 (.f64 re re) (.f64 im im)) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ -1 im))) (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 (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.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
2.0ms	re	@	0	((+ (* re re) (* im im)) (log (sqrt (+ (* re re) (* im im)))) (* re re) (* im im) (sqrt (+ (* re re) (* im im))))
2.0ms	re	@	inf	((+ (* re re) (* im im)) (log (sqrt (+ (* re re) (* im im)))) (* re re) (* im im) (sqrt (+ (* re re) (* im im))))
2.0ms	im	@	inf	((+ (* re re) (* im im)) (log (sqrt (+ (* re re) (* im im)))) (* re re) (* im im) (sqrt (+ (* re re) (* im im))))
1.0ms	im	@	0	((+ (* re re) (* im im)) (log (sqrt (+ (* re re) (* im im)))) (* re re) (* im im) (sqrt (+ (* re re) (* im im))))
1.0ms	im	@	-inf	((+ (* re re) (* im im)) (log (sqrt (+ (* re re) (* im im)))) (* re re) (* im im) (sqrt (+ (* re re) (* im im))))

simplify226.0ms (3.2%)

Memory

48.2MiB live, 232.3MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	186	1076
1	510	1054
2	1532	1044
3	5373	1010
0	8233	932

Stop Event

1×	iter limit
1×	node limit

Counts

96 → 92

Calls

Call 1

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

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

rewrite221.0ms (3.2%)

Memory

0.6MiB live, 269.7MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	7	30
0	12	30
1	31	30
2	199	30
3	1798	30
0	8149	19

Stop Event

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

Counts

5 → 260

Calls

Call 1

Inputs
(+.f64 (.f64 re re) (.f64 im im))
(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
(*.f64 re re)
(*.f64 im im)
(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

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

eval92.0ms (1.3%)

Memory: -18.6MiB live, 147.8MiB allocated
Compiler: Compiled 8 560 to 1 334 computations (84.4% saved)

prune6.0ms (0.1%)

Memory

28.4MiB live, 28.4MiB allocated

Pruning

4 alts after pruning (4 fresh and 0 done)

	Pruned	Kept	Total
New	348	4	352
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	349	4	353

Accuracy

100.0%

Counts

353 → 4

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	50.4%	(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
▶	100.0%	(log.f64 (hypot.f64 re im))
▶	99.4%	#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (*.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re (log.f64 im)))
▶	99.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))

Compiler

Compiled 28 to 24 computations (14.3% saved)

simplify7.0ms (0.1%)

Memory

-24.0MiB live, 13.7MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 12 expressions of interest:

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

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	21	94
0	33	94
1	44	94
2	67	94
3	91	94
4	105	94
5	107	94
0	107	94

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

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

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

localize56.0ms (0.8%)

Memory

-2.0MiB live, 115.4MiB allocated

Localize:

Found 12 expressions of interest:

New	Metric	Score
accuracy	0	(fma.f64 im im (*.f64 re re))
accuracy	0	(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
accuracy	0	(*.f64 re re)
accuracy	31.71931604145718	(log.f64 (fma.f64 im im (*.f64 re re)))
accuracy	0	(hypot.f64 re im)
accuracy	0	(log.f64 (hypot.f64 re im))
accuracy	0.0078125	(*.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64))
accuracy	0.01171875	(fma.f64 (*.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re (log.f64 im))
accuracy	0.125	(/.f64 (/.f64 re im) im)
accuracy	0.3558741261739966	#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (*.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re (log.f64 im)))
accuracy	0	(log.f64 im)
accuracy	0.6641359148342733	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))

Samples

43.0ms

256×

valid

Compiler

Compiled 105 to 18 computations (82.9% saved)

Precisions

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

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

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

ival-hypot: 5.0ms (16% of total)

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

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

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

exact: 0.0ms (0% of total)

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

series90.0ms (1.3%)

Memory

19.0MiB live, 165.4MiB allocated

Counts

12 → 264

Calls

Call 1

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

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

Calls

6 calls:

Time	Variable		Point	Expression
31.0ms	im	@	0	((log (sqrt (+ (* re re) (* im im)))) (log im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ (/ re im) im) 1/2) (/ (/ re im) im) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))
16.0ms	im	@	inf	((log (sqrt (+ (* re re) (* im im)))) (log im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ (/ re im) im) 1/2) (/ (/ re im) im) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))
13.0ms	im	@	-inf	((log (sqrt (+ (* re re) (* im im)))) (log im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ (/ re im) im) 1/2) (/ (/ re im) im) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))
10.0ms	re	@	0	((log (sqrt (+ (* re re) (* im im)))) (log im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ (/ re im) im) 1/2) (/ (/ re im) im) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))
6.0ms	re	@	-inf	((log (sqrt (+ (* re re) (* im im)))) (log im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ (/ re im) im) 1/2) (/ (/ re im) im) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (* (log (+ (* im im) (* re re))) 1/2) (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) (* re re))

simplify198.0ms (2.8%)

Memory

16.0MiB live, 336.5MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	271	3495
1	752	3405
2	2189	3379
3	5362	3367
0	8202	3141

Stop Event

1×	iter limit
1×	node limit

Counts

264 → 260

Calls

Call 1

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

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

rewrite257.0ms (3.7%)

Memory

6.2MiB live, 189.0MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	21	80
0	33	75
1	94	75
2	630	75
3	7448	75
0	8205	75

Stop Event

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

Counts

12 → 406

Calls

Call 1

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

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

eval83.0ms (1.2%)

Memory: 18.4MiB live, 172.2MiB allocated
Compiler: Compiled 14 832 to 1 907 computations (87.1% saved)

prune16.0ms (0.2%)

Memory

12.8MiB live, 48.8MiB allocated

Pruning

4 alts after pruning (2 fresh and 2 done)

	Pruned	Kept	Total
New	682	2	684
Fresh	0	0	0
Picked	2	2	4
Done	0	0	0
Total	684	4	688

Accuracy

100.0%

Counts

688 → 4

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	50.4%	(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
▶	99.5%	(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))
✓	99.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
▶	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im))))

Compiler

Compiled 33 to 27 computations (18.2% saved)

simplify8.0ms (0.1%)

Memory

-38.3MiB live, 10.0MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 8 expressions of interest:

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

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	23	126
0	30	126
1	51	126
2	74	126
3	89	126
4	97	126
0	97	109

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

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

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

localize47.0ms (0.7%)

Memory

18.3MiB live, 93.9MiB allocated

Localize:

Found 8 expressions of interest:

New	Metric	Score
accuracy	0	(/.f64 re im)
accuracy	0	(*.f64 re #s(literal 1/2 binary64))
accuracy	0	(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))
accuracy	0.4383641635692095	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))
accuracy	0	(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
accuracy	0.1953125	(.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im))
accuracy	0.3558741261739966	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im))))
accuracy	61.67333676366823	#s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im)))

Samples

38.0ms

256×

valid

Compiler

Compiled 78 to 18 computations (76.9% saved)

Precisions

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

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

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

ival-hypot: 6.0ms (21.6% of total)

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

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

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

exact: 0.0ms (0% of total)

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

series67.0ms (1%)

Memory

10.3MiB live, 47.1MiB allocated

Counts

9 → 204

Calls

Call 1

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

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

Calls

6 calls:

Time	Variable		Point	Expression
44.0ms	re	@	-inf	((* (* (/ re im) 1/2) (/ re im)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ re im) 1/2) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ re im) (* re 1/2)) im) (/ re im) (* re 1/2))
4.0ms	re	@	0	((* (* (/ re im) 1/2) (/ re im)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ re im) 1/2) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ re im) (* re 1/2)) im) (/ re im) (* re 1/2))
4.0ms	im	@	-inf	((* (* (/ re im) 1/2) (/ re im)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ re im) 1/2) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ re im) (* re 1/2)) im) (/ re im) (* re 1/2))
4.0ms	im	@	inf	((* (* (/ re im) 1/2) (/ re im)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ re im) 1/2) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ re im) (* re 1/2)) im) (/ re im) (* re 1/2))
3.0ms	re	@	inf	((* (* (/ re im) 1/2) (/ re im)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ re im) 1/2) (log (sqrt (+ (* re re) (* im im)))) (sqrt (+ (* re re) (* im im))) (+ (* (/ re im) (* re 1/2)) im) (/ re im) (* re 1/2))

simplify217.0ms (3.1%)

Memory

-19.4MiB live, 216.5MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	204	2237
1	541	2189
2	1606	2171
3	5406	2137
0	8263	2013

Stop Event

1×	iter limit
1×	node limit

Counts

204 → 197

Calls

Call 1

Inputs
(* 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)))
(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))
(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)))
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 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 (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))
(* -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))))
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 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 (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))
(* -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))))
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 1/2 re)
(* 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)))
(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 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)
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(* 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 (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)))
(+ (* -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)))))
(/ re im)
(/ re im)
(/ re im)
(/ re im)
(* 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 (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))
(* -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)))
(/ re im)
(/ re im)
(/ re im)
(/ re im)

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

rewrite172.0ms (2.5%)

Memory

33.7MiB live, 259.9MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	23	117
0	30	117
1	104	117
2	725	107
3	7021	107
0	8660	90

Stop Event

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

Counts

9 → 210

Calls

Call 1

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

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

eval129.0ms (1.8%)

Memory: -13.5MiB live, 138.2MiB allocated
Compiler: Compiled 8 241 to 1 230 computations (85.1% saved)

prune154.0ms (2.2%)

Memory

2.3MiB live, 201.1MiB allocated

Pruning

17 alts after pruning (13 fresh and 4 done)

	Pruned	Kept	Total
New	486	13	499
Fresh	0	0	0
Picked	0	2	2
Done	0	2	2
Total	486	17	503

Accuracy

100.0%

Counts

503 → 17

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	50.4%	(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
✓	99.5%	(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))
✓	99.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
▶	3.7%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)))
	3.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) re) (*.f64 im im))))
	3.2%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re))))
	3.5%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 #s(literal -1/2 binary64) re) (.f64 (/.f64 (neg.f64 im) re) im))))
▶	3.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re)))))
▶	3.7%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))))
	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 im re) (/.f64 im re)))))
	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) (neg.f64 im)) (neg.f64 re))))
	3.7%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 (/.f64 re im) re))))
▶	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)))
✓	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im))))
▶	3.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))))
	3.2%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (neg.f64 re) (/.f64 (.f64 #s(literal 1/2 binary64) re) (*.f64 (neg.f64 im) im)))))
	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (neg.f64 re) (.f64 (/.f64 #s(literal -1 binary64) im) (*.f64 #s(literal 1/2 binary64) (/.f64 re im))))))

Compiler

Compiled 343 to 283 computations (17.5% saved)

simplify19.0ms (0.3%)

Memory

13.1MiB live, 45.5MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

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

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	45	429
0	64	447
1	106	447
2	181	417
3	287	417
4	495	417
5	561	417
6	584	417
0	584	382

Stop Event

1×	iter limit
1×	saturated
1×	iter limit

Calls

Call 1

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

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

localize417.0ms (5.9%)

Memory

-84.9MiB live, 228.7MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.3558741261739966	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re)))))
accuracy	0.4878110108717155	(/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re)))
accuracy	13.956705504271238	(/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re))
accuracy	61.67333676366823	#s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re))))
accuracy	0.1015625	(.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re)
accuracy	0.3558741261739966	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)))
accuracy	3.3034728381066656	(/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)
accuracy	61.67333676366823	#s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))
accuracy	0.125	(/.f64 (/.f64 re im) im)
accuracy	0.3558741261739966	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)))
accuracy	3.2080770436813872	(.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)
accuracy	61.67333676366823	#s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))
accuracy	0.28080354817906394	(/.f64 #s(literal 1/2 binary64) (*.f64 im im))
accuracy	0.3558741261739966	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))))
accuracy	14.23247293126104	(.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))
accuracy	61.67333676366823	#s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))))
accuracy	0.3558741261739966	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))))
accuracy	0.4878110108717155	(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))
accuracy	3.9111171950116437	(*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)
accuracy	61.67333676366823	#s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))

Samples

388.0ms

256×

valid

Compiler

Compiled 258 to 30 computations (88.4% saved)

Precisions

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

ival-div: 294.0ms (79.5% of total)

ival-mult: 63.0ms (17% of total)

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

ival-hypot: 5.0ms (1.4% of total)

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

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

exact: 0.0ms (0% of total)

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

series86.0ms (1.2%)

Memory

-22.5MiB live, 126.8MiB allocated

Counts

23 → 516

Calls

Call 1

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

Outputs
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.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/2 (/ re (pow im 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<representation binary64>) () ())) ())
#s(alt (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2)))) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re))))) #<representation binary64>) () ())) ())
#s(alt (log im) (taylor 0 re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re)))) #<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 (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.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/2 (/ re (pow im 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re))))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re)))) #<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 (* 2 (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.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/2 (/ re (pow im 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf re) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf re) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re))))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf re) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re)))) #<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 (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf re) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor 0 im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor 0 im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (log re) (taylor 0 im) (#s(alt #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re))))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor 0 im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re)))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor 0 im) (#s(alt (.f64 im im) (patch (.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 (/ 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 (/ 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 (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor 0 im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor inf im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor inf im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re))))) #<representation binary64>) () ())) ())
#s(alt (* -1 (log (/ 1 im))) (taylor inf im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re)))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor inf im) (#s(alt (.f64 im im) (patch (.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 (/ 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 (/ 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 (* 2 (/ (pow im 2) (pow re 2))) (taylor inf im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor inf im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) (patch (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)))) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) (patch (.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im))))) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<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) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (patch (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ re (pow im 2))) (taylor -inf im) (#s(alt (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) (patch (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re))) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re) (patch (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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 re im)) re) im) (patch (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) 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)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) 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 #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) (patch #s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im))) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<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) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) (patch #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) im)) (taylor -inf im) (#s(alt (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) (patch (.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<representation binary64>) () ())) ())
#s(alt (* 1/2 (/ (pow re 2) (pow im 2))) (taylor -inf im) (#s(alt (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) (patch (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))) #<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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re))))) (patch #s(approx (log (sqrt (+ ( re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re))))) #<representation binary64>) () ())) ())
#s(alt (+ (log -1) (* -1 (log (/ -1 im)))) (taylor -inf im) (#s(alt #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) 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) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)))) (patch #s(approx (+ ( (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (.f64 im im) (.f64 (*.f64 #s(literal 1/2 binary64) re) re)))) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.f64 im im) #<representation binary64>) () ())) ())
#s(alt (pow im 2) (taylor -inf im) (#s(alt (.f64 im im) (patch (.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 (/ 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 (/ 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 (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())
#s(alt (* 2 (/ (pow im 2) (pow re 2))) (taylor -inf im) (#s(alt (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) (patch (/.f64 (.f64 im im) (.f64 (.f64 #s(literal 1/2 binary64) re) re)) #<representation binary64>) () ())) ())

Calls

6 calls:

Time	Variable		Point	Expression
35.0ms	re	@	0	((/ 1 (* (/ (/ (/ im re) 1/2) re) im)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ (/ (/ im re) 1/2) re) im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* re re) (/ 1/2 (* im im))) (* re re) (* (/ (/ re im) im) 1/2) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* (/ (/ re im) im) 1/2) re) (/ (* (* 1/2 (/ re im)) re) im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* 1/2 (/ re im)) re) (/ 1 (/ (* im im) (* (* 1/2 re) re))) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* im im) (/ 1/2 (* im im)) (/ (/ re im) im) (/ (* im im) (* (* 1/2 re) re)))
10.0ms	im	@	0	((/ 1 (* (/ (/ (/ im re) 1/2) re) im)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ (/ (/ im re) 1/2) re) im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* re re) (/ 1/2 (* im im))) (* re re) (* (/ (/ re im) im) 1/2) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* (/ (/ re im) im) 1/2) re) (/ (* (* 1/2 (/ re im)) re) im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* 1/2 (/ re im)) re) (/ 1 (/ (* im im) (* (* 1/2 re) re))) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* im im) (/ 1/2 (* im im)) (/ (/ re im) im) (/ (* im im) (* (* 1/2 re) re)))
5.0ms	im	@	inf	((/ 1 (* (/ (/ (/ im re) 1/2) re) im)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ (/ (/ im re) 1/2) re) im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* re re) (/ 1/2 (* im im))) (* re re) (* (/ (/ re im) im) 1/2) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* (/ (/ re im) im) 1/2) re) (/ (* (* 1/2 (/ re im)) re) im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* 1/2 (/ re im)) re) (/ 1 (/ (* im im) (* (* 1/2 re) re))) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* im im) (/ 1/2 (* im im)) (/ (/ re im) im) (/ (* im im) (* (* 1/2 re) re)))
4.0ms	im	@	-inf	((/ 1 (* (/ (/ (/ im re) 1/2) re) im)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ (/ (/ im re) 1/2) re) im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* re re) (/ 1/2 (* im im))) (* re re) (* (/ (/ re im) im) 1/2) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* (/ (/ re im) im) 1/2) re) (/ (* (* 1/2 (/ re im)) re) im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* 1/2 (/ re im)) re) (/ 1 (/ (* im im) (* (* 1/2 re) re))) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* im im) (/ 1/2 (* im im)) (/ (/ re im) im) (/ (* im im) (* (* 1/2 re) re)))
4.0ms	re	@	inf	((/ 1 (* (/ (/ (/ im re) 1/2) re) im)) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (/ (/ (/ im re) 1/2) re) im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* re re) (/ 1/2 (* im im))) (* re re) (* (/ (/ re im) im) 1/2) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* (/ (/ re im) im) 1/2) re) (/ (* (* 1/2 (/ re im)) re) im) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* (* 1/2 (/ re im)) re) (/ 1 (/ (* im im) (* (* 1/2 re) re))) (log (sqrt (+ (* re re) (* im im)))) (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (* im im) (/ 1/2 (* im im)) (/ (/ re im) im) (/ (* im im) (* (* 1/2 re) re)))

simplify304.0ms (4.3%)

Memory

45.7MiB live, 510.4MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	120	5805
1	281	5675
2	724	5635
3	1730	5635
4	4644	5635
0	8204	5395

Stop Event

1×	iter limit
1×	node limit

Counts

516 → 516

Calls

Call 1

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

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

rewrite201.0ms (2.9%)

Memory

-21.3MiB live, 399.2MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	45	375
0	64	393
1	193	363
2	1095	309
0	8231	274

Stop Event

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

Counts

23 → 1 355

Calls

Call 1

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

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

eval390.0ms (5.6%)

Memory: 27.3MiB live, 439.1MiB allocated
Compiler: Compiled 25 458 to 2 615 computations (89.7% saved)

prune217.0ms (3.1%)

Memory

-22.6MiB live, 306.2MiB allocated

Pruning

27 alts after pruning (21 fresh and 6 done)

	Pruned	Kept	Total
New	1 880	18	1 898
Fresh	5	3	8
Picked	3	2	5
Done	0	4	4
Total	1 888	27	1 915

Accuracy

100.0%

Counts

1 915 → 27

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	50.4%	(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
✓	99.5%	(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))
✓	99.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (/.f64 (/.f64 re im) im) (/.f64 #s(literal 2 binary64) re))))
	3.5%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) re) im) im)))
	3.7%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (/.f64 #s(literal 1/2 binary64) im) (/.f64 (/.f64 im re) re))))
	3.5%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (*.f64 (/.f64 re (/.f64 #s(literal -1 binary64) re)) (/.f64 #s(literal -1/2 binary64) im)) im)))
	3.5%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 re re)) im)))
	3.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 #s(literal 1/2 binary64) re) re) (*.f64 im im))))
	3.5%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 #s(literal 1/2 binary64) re) (.f64 (/.f64 im re) im))))
	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (/.f64 (/.f64 im re) (*.f64 (/.f64 re im) #s(literal 1/2 binary64))))))
	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 #s(literal -1 binary64) re) (/.f64 #s(literal -1/2 binary64) im)) (/.f64 im re)))))
	3.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 2 binary64) (.f64 re re)) (*.f64 im im)))))
	3.5%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1 binary64) (.f64 (/.f64 #s(literal 2 binary64) re) (.f64 (/.f64 im re) im)))))
	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 #s(literal 1/2 binary64) (*.f64 (/.f64 im re) (/.f64 im re)))))
	3.2%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (/.f64 (.f64 #s(literal 1/2 binary64) re) (*.f64 im im)) re)))
	3.5%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 (/.f64 im re) im)) re)))
	3.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (/.f64 #s(literal 1/2 binary64) (.f64 im im)) (/.f64 (neg.f64 re) (/.f64 #s(literal -1 binary64) re)))))
	3.7%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (/.f64 #s(literal 1/2 binary64) im) (.f64 (/.f64 re im) re))))
✓	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re)))
	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 re im) (/.f64 #s(literal 1/2 binary64) im)) re)))
✓	3.6%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im))))
	3.2%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 #s(literal 1/2 binary64) (*.f64 im im)) re) re)))
	3.2%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (neg.f64 re) (*.f64 (/.f64 #s(literal -1 binary64) im) (/.f64 #s(literal 1/2 binary64) im))) re)))
	3.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 (/.f64 #s(literal 1/2 binary64) im) im))))
✓	3.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))))
	3.0%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (*.f64 (/.f64 #s(literal -1/2 binary64) im) (/.f64 #s(literal -1 binary64) im)))))

Compiler

Compiled 737 to 426 computations (42.2% saved)

regimes147.0ms (2.1%)

Memory

30.8MiB live, 178.7MiB allocated

Counts

38 → 1

Calls

Call 1

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

Outputs
(log.f64 (hypot.f64 re im))

Calls

7 calls:

50.0ms	im
35.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
16.0ms	(*.f64 im im)
12.0ms	(+.f64 (.f64 re re) (.f64 im im))
11.0ms	re

Results

Accuracy	Segments	Branch
100.0%	1	`re`
100.0%	1	`im`
100.0%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
100.0%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
100.0%	1	`(+.f64 (.f64 re re) (.f64 im im))`
100.0%	1	`(*.f64 re re)`
100.0%	1	`(*.f64 im im)`

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes105.0ms (1.5%)

Memory

-86.7MiB live, 170.6MiB allocated

Counts

37 → 1

Calls

Call 1

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

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

Calls

7 calls:

29.0ms	re
16.0ms	(*.f64 im im)
12.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
12.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
12.0ms	(*.f64 re re)

Results

Accuracy	Segments	Branch
99.5%	1	`re`
99.5%	1	`im`
99.5%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
99.5%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
99.5%	1	`(+.f64 (.f64 re re) (.f64 im im))`
99.5%	1	`(*.f64 re re)`
99.5%	1	`(*.f64 im im)`

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes113.0ms (1.6%)

Memory

30.6MiB live, 185.6MiB allocated

Counts

34 → 1

Calls

Call 1

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

Outputs
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))

Calls

7 calls:

30.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
27.0ms	re
14.0ms	(*.f64 re re)
11.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
10.0ms	im

Results

Accuracy	Segments	Branch
99.0%	1	`re`
99.0%	1	`im`
99.0%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
99.0%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
99.0%	1	`(+.f64 (.f64 re re) (.f64 im im))`
99.0%	1	`(*.f64 re re)`
99.0%	1	`(*.f64 im im)`

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes81.0ms (1.2%)

Memory

16.8MiB live, 165.5MiB allocated

Counts

32 → 1

Calls

Call 1

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

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

Calls

7 calls:

20.0ms	im
11.0ms	(*.f64 im im)
11.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
11.0ms	(+.f64 (.f64 re re) (.f64 im im))
9.0ms	re

Results

Accuracy	Segments	Branch
3.7%	1	`re`
3.7%	1	`im`
3.7%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
3.7%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
3.7%	1	`(+.f64 (.f64 re re) (.f64 im im))`
3.7%	1	`(*.f64 re re)`
3.7%	1	`(*.f64 im im)`

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes70.0ms (1%)

Memory

-4.9MiB live, 147.9MiB allocated

Counts

25 → 1

Calls

Call 1

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

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

Calls

7 calls:

18.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
12.0ms	(*.f64 re re)
9.0ms	(*.f64 im im)
8.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
8.0ms	im

Results

Accuracy	Segments	Branch
3.7%	1	`im`
3.7%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
3.7%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
3.7%	1	`(+.f64 (.f64 re re) (.f64 im im))`
3.7%	1	`(*.f64 im im)`
3.7%	1	`re`
3.7%	1	`(*.f64 re re)`

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes87.0ms (1.2%)

Memory

-13.8MiB live, 101.7MiB allocated

Counts

13 → 1

Calls

Call 1

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

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

Calls

7 calls:

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

Results

Accuracy	Segments	Branch
3.7%	1	`re`
3.7%	1	`im`
3.7%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
3.7%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
3.7%	1	`(+.f64 (.f64 re re) (.f64 im im))`
3.7%	1	`(*.f64 im im)`
3.7%	1	`(*.f64 re re)`

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes34.0ms (0.5%)

Memory

-16.8MiB live, 92.0MiB allocated

Counts

9 → 1

Calls

Call 1

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

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

Calls

7 calls:

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

Results

Accuracy	Segments	Branch
3.6%	1	`im`
3.6%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
3.6%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
3.6%	1	`(+.f64 (.f64 re re) (.f64 im im))`
3.6%	1	`(*.f64 im im)`
3.6%	1	`re`
3.6%	1	`(*.f64 re re)`

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes21.0ms (0.3%)

Memory

16.8MiB live, 54.1MiB allocated

Counts

6 → 1

Calls

Call 1

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

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

Calls

7 calls:

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

Results

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

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes58.0ms (0.8%)

Memory

-11.9MiB live, 24.8MiB allocated

Accuracy

Total 0.0b remaining (0%)

Threshold costs 0b (0%)

Counts

1 → 1

Calls

Call 1

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

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

Calls

7 calls:

50.0ms	(*.f64 im im)
1.0ms	im
1.0ms	re
1.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
1.0ms	(+.f64 (.f64 re re) (.f64 im im))

Results

Accuracy	Segments	Branch
3.0%	1	`im`
3.0%	1	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`
3.0%	1	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
3.0%	1	`(+.f64 (.f64 re re) (.f64 im im))`
3.0%	1	`(*.f64 im im)`
3.0%	1	`re`
3.0%	1	`(*.f64 re re)`

Compiler

Compiled 32 to 28 computations (12.5% saved)

simplify25.0ms (0.4%)

Memory

5.8MiB live, 50.8MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	52	226
1	61	226

Stop Event

1×

saturated

Calls

Call 1

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

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

soundness1.2s (17.7%)

Memory

37.9MiB live, 955.3MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	271	3495
1	752	3405
2	2189	3379
3	5362	3367
0	8202	3141
0	7	30
0	12	30
1	31	30
2	199	30
3	1798	30
0	8149	19
0	186	1076
1	510	1054
2	1532	1044
3	5373	1010
0	8233	932
0	45	375
0	64	393
1	193	363
2	1095	309
0	8231	274
0	23	117
0	30	117
1	104	117
2	725	107
3	7021	107
0	8660	90

Stop Event

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

Compiler

Compiled 265 to 188 computations (29.1% saved)

preprocess115.0ms (1.6%)

Memory

-12.0MiB live, 199.0MiB allocated

Remove

(sort re im)

(abs re)

(abs im)

Compiler

Compiled 280 to 190 computations (32.1% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

Iter	Nodes	Cost
0	45	429
0	64	447
1	106	447
2	181	417
3	287	417
4	495	417
5	561	417
6	584	417
0	584	382

Iter	Nodes	Cost
0	45	429
0	64	447
1	106	447
2	181	417
3	287	417
4	495	417
5	561	417
6	584	417
0	584	382

start0.0ms (0%)

analyze46.0ms (0.7%)

sample938.0ms (13.4%)

explain154.0ms (2.2%)

preprocess18.0ms (0.3%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify3.0ms (0%)

localize42.0ms (0.6%)

series29.0ms (0.4%)

simplify226.0ms (3.2%)

rewrite221.0ms (3.2%)

eval92.0ms (1.3%)

prune6.0ms (0.1%)

simplify7.0ms (0.1%)

localize56.0ms (0.8%)

series90.0ms (1.3%)

simplify198.0ms (2.8%)

rewrite257.0ms (3.7%)

eval83.0ms (1.2%)

prune16.0ms (0.2%)

simplify8.0ms (0.1%)

localize47.0ms (0.7%)

series67.0ms (1%)

simplify217.0ms (3.1%)

rewrite172.0ms (2.5%)

eval129.0ms (1.8%)

prune154.0ms (2.2%)

simplify19.0ms (0.3%)

localize417.0ms (5.9%)

series86.0ms (1.2%)

simplify304.0ms (4.3%)

rewrite201.0ms (2.9%)

eval390.0ms (5.6%)

prune217.0ms (3.1%)

regimes147.0ms (2.1%)

regimes105.0ms (1.5%)

regimes113.0ms (1.6%)

regimes81.0ms (1.2%)

regimes70.0ms (1%)

regimes87.0ms (1.2%)

regimes34.0ms (0.5%)

regimes21.0ms (0.3%)

regimes58.0ms (0.8%)

simplify25.0ms (0.4%)

soundness1.2s (17.7%)

preprocess115.0ms (1.6%)

end0.0ms (0%)

Profiling

Iter	Nodes	Cost
0	45	429
0	64	447
1	106	447
2	181	417
3	287	417
4	495	417
5	561	417
6	584	417
0	584	382