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

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated

analyze80.0ms (1%)

Memory

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

sample980.0ms (12.8%)

Memory

62.6MiB live, 752.4MiB allocated

Samples

682.0ms

8 256×

valid

Precisions

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

ival-hypot: 235.0ms (60.4% of total)

ival-log: 144.0ms (37% of total)

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

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

Bogosity

explain265.0ms (3.5%)

Memory

-22.8MiB live, 142.4MiB allocated

FPErrors

Click to see full error table

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

Confusion

	Predicted +	Predicted -
+	126	0
-	0	130

Precision

1.0

Recall

1.0

Confusion?

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

Precision?

1.0

Recall?

1.0

Freqs

test

number	freq
0	130
1	126

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

40.0ms

512×

valid

Compiler

Compiled 77 to 25 computations (67.5% saved)

Precisions

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

ival-hypot: 9.0ms (35.1% of total)

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

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

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

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

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

preprocess16.0ms (0.2%)

Memory

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

prune0.0ms (0%)

Memory

1.0MiB live, 1.0MiB allocated

Alt Table

Click to see full alt table

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

Compiler

Compiled 9 to 7 computations (22.2% saved)

simplify35.0ms (0.5%)

Memory

-34.0MiB live, 3.1MiB 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

localize28.0ms (0.4%)

Memory

7.6MiB live, 45.1MiB 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	29.2957857036141	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Samples

20.0ms

256×

valid

Compiler

Compiled 34 to 9 computations (73.5% saved)

Precisions

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

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

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

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

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

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

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

series11.0ms (0.1%)

Memory

26.4MiB live, 26.4MiB 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	@	inf	((+ (* re re) (* im im)) (log (sqrt (+ (* re re) (* im im)))) (* re re) (* im im) (sqrt (+ (* re re) (* im im))))
2.0ms	re	@	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))))
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))))

simplify157.0ms (2.1%)

Memory

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

rewrite510.0ms (6.7%)

Memory

-180.1MiB live, 315.8MiB 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>

eval76.0ms (1%)

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

prune9.0ms (0.1%)

Memory

-18.1MiB live, 28.0MiB 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
▶	52.3%	(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
▶	100.0%	(log.f64 (hypot.f64 re im))
▶	99.8%	#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.2%	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))

Compiler

Compiled 28 to 24 computations (14.3% saved)

simplify5.0ms (0.1%)

Memory

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

localize65.0ms (0.8%)

Memory

-12.2MiB live, 225.3MiB 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	30.50866189745302	(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.01171875	(*.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64))
accuracy	0.01953125	(fma.f64 (*.f64 (/.f64 (/.f64 re im) im) #s(literal 1/2 binary64)) re (log.f64 im))
accuracy	0.14121982111577788	#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.1796875	(/.f64 (/.f64 re im) im)
accuracy	0	(log.f64 im)
accuracy	0.5291350786000174	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))

Samples

48.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: 11.0ms (35% of total)

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

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

ival-div: 3.0ms (9.5% 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)

series84.0ms (1.1%)

Memory

25.5MiB live, 222.3MiB 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
32.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))
12.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))
9.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))
4.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))

simplify186.0ms (2.4%)

Memory

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

rewrite261.0ms (3.4%)

Memory

21.7MiB live, 216.2MiB 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>

eval170.0ms (2.2%)

Memory: -7.9MiB live, 187.0MiB allocated
Compiler: Compiled 14 832 to 1 907 computations (87.1% saved)

prune50.0ms (0.7%)

Memory

4.3MiB live, 92.0MiB allocated

Pruning

5 alts after pruning (2 fresh and 3 done)

	Pruned	Kept	Total
New	682	2	684
Fresh	0	0	0
Picked	1	3	4
Done	0	0	0
Total	683	5	688

Accuracy

100.0%

Counts

688 → 5

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	52.3%	(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
✓	100.0%	(log.f64 (hypot.f64 re im))
▶	99.8%	(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))
✓	99.2%	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
▶	3.5%	#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 37 to 31 computations (16.2% saved)

simplify5.0ms (0.1%)

Memory

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

localize59.0ms (0.8%)

Memory

-7.1MiB live, 69.5MiB 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.24772269093428995	#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im))
accuracy	0.0078125	(*.f64 (/.f64 re im) #s(literal 1/2 binary64))
accuracy	0.14121982111577788	#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	0.24609375	(.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im))
accuracy	61.778696377164884	#s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) (/.f64 re im)))

Samples

49.0ms

256×

valid

Compiler

Compiled 78 to 18 computations (76.9% saved)

Precisions

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

ival-mult: 21.0ms (54.5% of total)

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

ival-div: 4.0ms (10.4% of total)

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

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

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

exact: 0.0ms (0% of total)

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

series48.0ms (0.6%)

Memory

-16.3MiB live, 64.3MiB 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
22.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))
3.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))

simplify189.0ms (2.5%)

Memory

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

rewrite231.0ms (3%)

Memory

-20.6MiB live, 291.7MiB 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>

eval104.0ms (1.4%)

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

prune53.0ms (0.7%)

Memory

-5.7MiB live, 152.5MiB allocated

Pruning

20 alts after pruning (15 fresh and 5 done)

	Pruned	Kept	Total
New	484	15	499
Fresh	0	0	0
Picked	0	2	2
Done	0	3	3
Total	484	20	504

Accuracy

100.0%

Counts

504 → 20

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	52.3%	(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
✓	100.0%	(log.f64 (hypot.f64 re im))
✓	99.8%	(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))
✓	99.2%	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
	2.8%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 re re) #s(literal -1/2 binary64)) (*.f64 (neg.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 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) re) im)))
	2.8%	#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) (/.f64 re im)) (/.f64 im re))))
▶	3.1%	#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.4%	#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))))
	2.8%	#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.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 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) 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/2 binary64) (*.f64 (/.f64 im re) (/.f64 im re)))))
	3.4%	#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 1/2 binary64) re))))
▶	3.4%	#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.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) im) (.f64 (/.f64 re im) 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 im) #s(literal 1/2 binary64)) (/.f64 re im))))
▶	2.8%	#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.1%	#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.4%	#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 393 to 325 computations (17.3% saved)

simplify203.0ms (2.6%)

Memory

7.0MiB live, 157.8MiB allocated

Algorithm

1×	egg-herbie

Localize:

Found 20 expressions of interest:

New	Metric	Score
cost-diff	0	#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)))
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)) (neg.f64 im)) (neg.f64 re))))
cost-diff	128	(/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) (neg.f64 im))
cost-diff	128	(.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) (neg.f64 im)) (neg.f64 re))
cost-diff	0	(*.f64 #s(literal 1/2 binary64) re)
cost-diff	0	(/.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re))
cost-diff	0	#s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re)))
cost-diff	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) re) (/.f64 (.f64 im im) re))))
cost-diff	0	(neg.f64 re)
cost-diff	0	#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))))
cost-diff	0	#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)))))
cost-diff	128	(.f64 (neg.f64 re) (/.f64 (.f64 #s(literal 1/2 binary64) re) (*.f64 (neg.f64 im) im)))
cost-diff	0	(/.f64 #s(literal 1/2 binary64) (*.f64 im im))
cost-diff	0	(*.f64 re re)
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	#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	384	(/.f64 (/.f64 im re) #s(literal 1/2 binary64))
cost-diff	704	(/.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	46	434
0	66	446
1	126	444
2	307	444
3	972	414
4	2345	414
5	3647	414
6	5352	414
7	6359	414
8	6389	414
9	6399	414
10	6403	414
11	6554	414
12	6619	414
13	6619	414
14	6619	414
15	6811	414
16	7825	414
0	8099	379

Stop Event

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

localize119.0ms (1.6%)

Memory

31.8MiB live, 266.7MiB allocated

Localize:

Found 20 expressions of interest:

New	Metric	Score
accuracy	0.14121982111577788	#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))))
accuracy	0.1796875	(/.f64 (*.f64 #s(literal 1/2 binary64) (/.f64 re im)) (neg.f64 im))
accuracy	3.939077662975699	(.f64 (/.f64 (.f64 #s(literal 1/2 binary64) (/.f64 re im)) (neg.f64 im)) (neg.f64 re))
accuracy	61.778696377164884	#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)))
accuracy	0.14121982111577788	#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))))
accuracy	4.203359384434427	(/.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re))
accuracy	9.20770317992593	(/.f64 (*.f64 im im) re)
accuracy	61.778696377164884	#s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 #s(literal 1/2 binary64) re) (/.f64 (.f64 im im) re)))
accuracy	0.14121982111577788	#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)))))
accuracy	3.939077662975699	(.f64 (neg.f64 re) (/.f64 (.f64 #s(literal 1/2 binary64) re) (*.f64 (neg.f64 im) im)))
accuracy	9.403319965981709	(/.f64 (.f64 #s(literal 1/2 binary64) re) (.f64 (neg.f64 im) im))
accuracy	61.778696377164884	#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))))
accuracy	0.14121982111577788	#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	0.5837113758778032	(/.f64 #s(literal 1/2 binary64) (*.f64 im im))
accuracy	16.173936806076416	(.f64 (.f64 re re) (/.f64 #s(literal 1/2 binary64) (*.f64 im im)))
accuracy	61.778696377164884	#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.14121982111577788	#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.39266389322566997	(/.f64 #s(literal 1 binary64) (*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im))
accuracy	3.1755516852485184	(*.f64 (/.f64 (/.f64 (/.f64 im re) #s(literal 1/2 binary64)) re) im)
accuracy	61.778696377164884	#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

93.0ms

256×

valid

Compiler

Compiled 259 to 34 computations (86.9% saved)

Precisions

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

ival-mult: 28.0ms (39.7% of total)

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

ival-add: 12.0ms (17% of total)

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

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

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

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

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

exact: 0.0ms (0% of total)

series58.0ms (0.8%)

Memory

1.4MiB live, 149.8MiB allocated

Counts

24 → 528

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

Calls

6 calls:

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

simplify376.0ms (4.9%)

Memory

1.8MiB live, 407.9MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	124	5733
1	289	5603
2	733	5563
3	1746	5563
4	4678	5563
0	8230	5323

Stop Event

1×	iter limit
1×	node limit

Counts

528 → 528

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

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

rewrite181.0ms (2.4%)

Memory

-12.4MiB live, 286.7MiB allocated

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	46	381
0	66	393
1	219	361
2	1302	361
3	7310	361
0	8562	326

Stop Event

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

Counts

24 → 957

Calls

Call 1

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

eval214.0ms (2.8%)

Memory: 8.1MiB live, 601.6MiB allocated
Compiler: Compiled 21 764 to 2 530 computations (88.4% saved)

prune155.0ms (2%)

Memory

21.8MiB live, 259.2MiB allocated

Pruning

43 alts after pruning (37 fresh and 6 done)

	Pruned	Kept	Total
New	1 519	32	1 551
Fresh	5	5	10
Picked	4	1	5
Done	0	5	5
Total	1 528	43	1 571

Accuracy

100.0%

Counts

1 571 → 43

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	52.3%	(.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64))
✓	100.0%	(log.f64 (hypot.f64 re im))
✓	99.8%	(log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 re im) (*.f64 re #s(literal 1/2 binary64)) im)))
✓	99.2%	#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
	3.5%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (/.f64 re im) (*.f64 #s(literal 2 binary64) (/.f64 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) 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 im) re) (.f64 #s(literal 2 binary64) im))))
	2.8%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (/.f64 (.f64 (.f64 re re) #s(literal -1/2 binary64)) (*.f64 (neg.f64 im) im))))
	2.8%	#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 2 binary64) (*.f64 im im)))))
	3.4%	#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 #s(literal -1 binary64) (/.f64 (/.f64 (neg.f64 re) im) im)))))
	3.4%	#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.1%	#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 #s(literal -1 binary64) re) (*.f64 (neg.f64 im) im)))))
	3.4%	#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 (/.f64 (/.f64 im re) re)) re))))
	3.4%	#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 1 binary64) (*.f64 #s(literal -1/2 binary64) re)) (/.f64 (/.f64 (neg.f64 re) im) im)))))
	2.8%	#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 (neg.f64 im) im) (.f64 (.f64 (.f64 #s(literal -1/2 binary64) (/.f64 re im)) re) im)))))
	2.8%	#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.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) im) (.f64 (/.f64 re im) re)))))
	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 (/.f64 (/.f64 #s(literal 2 binary64) (/.f64 #s(literal -1 binary64) im)) (neg.f64 re)) re) 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 (/.f64 (/.f64 #s(literal -1 binary64) re) (/.f64 #s(literal -1/2 binary64) im)) re) im))))
	2.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 (.f64 (neg.f64 im) im) (.f64 (.f64 #s(literal -1/2 binary64) re) im)) re) 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 (/.f64 #s(literal 2 binary64) (/.f64 re im)) re) im))))
	2.8%	#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 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 #s(literal 1 binary64) (.f64 (/.f64 (.f64 (/.f64 #s(literal 2 binary64) re) im) re) im))))
	3.3%	#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 -2 binary64) (.f64 (/.f64 im re) im)) (.f64 (neg.f64 re) re)) re))))
	3.4%	#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.5%	#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.5%	#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 im (/.f64 (/.f64 im re) re)))))
	3.4%	#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 1/2 binary64) re))))
	2.8%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (/.f64 (.f64 (neg.f64 re) re) re) (/.f64 (.f64 #s(literal 1/2 binary64) re) (.f64 (neg.f64 im) im)))))
	3.3%	#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)) (/.f64 (*.f64 (neg.f64 re) re) re))))
	3.4%	#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)) (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) re)))))
	3.1%	#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)) (neg.f64 re))))
	2.8%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (/.f64 #s(literal 1 binary64) (/.f64 re (.f64 (neg.f64 re) re))) (/.f64 (.f64 #s(literal 1/2 binary64) re) (.f64 (neg.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) im) (.f64 (/.f64 re im) re))))
	3.4%	#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)) (neg.f64 re))))
	3.1%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 (/.f64 (.f64 (/.f64 re im) #s(literal 1/2 binary64)) (.f64 (neg.f64 im) im)) im) (neg.f64 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 im) #s(literal 1/2 binary64)) (/.f64 re im))))
	3.4%	#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 im)) re)))
	2.8%	#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))))
✓	2.8%	#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)))))
	2.7%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (.f64 re re) (.f64 (/.f64 (/.f64 #s(literal -1/2 binary64) im) (.f64 (neg.f64 im) im)) im))))
	2.8%	#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)))))
	3.1%	#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(approx (+ (* (* (/ (/ re im) im) 1/2) re) (log im)) (.f64 (neg.f64 re) #s(approx (/ ( 1/2 re) (* (neg im) im)) (.f64 (/.f64 #s(literal -1/2 binary64) (.f64 im im)) re)))))

Compiler

Compiled 1 240 to 713 computations (42.5% saved)

regimes177.0ms (2.3%)

Memory

-36.9MiB live, 202.1MiB allocated

Counts

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

41.0ms	(+.f64 (.f64 re re) (.f64 im im))
35.0ms	(*.f64 im im)
35.0ms	re
18.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
17.0ms	im

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)

regimes125.0ms (1.6%)

Memory

-18.0MiB live, 262.1MiB allocated

Counts

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

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

Results

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

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes149.0ms (2%)

Memory

10.5MiB live, 195.2MiB allocated

Counts

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

35.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
34.0ms	(+.f64 (.f64 re re) (.f64 im im))
18.0ms	im
15.0ms	re
14.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))

Results

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

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes142.0ms (1.9%)

Memory

16.3MiB live, 170.0MiB allocated

Counts

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

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:

36.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
25.0ms	(*.f64 re re)
20.0ms	re
16.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
14.0ms	im

Results

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

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes84.0ms (1.1%)

Memory

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

Outputs
#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 im (/.f64 (/.f64 im re) re)))))

Calls

7 calls:

17.0ms	re
11.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
11.0ms	(+.f64 (.f64 re re) (.f64 im im))
10.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
10.0ms	im

Results

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

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes59.0ms (0.8%)

Memory

53.3MiB live, 157.8MiB allocated

Counts

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

12.0ms	(*.f64 im im)
10.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
9.0ms	re
7.0ms	im
6.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))

Results

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

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes39.0ms (0.5%)

Memory

-7.8MiB live, 71.6MiB allocated

Counts

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

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:

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

Results

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

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes27.0ms (0.4%)

Memory

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

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) im) (/.f64 re im)) re)))

Calls

7 calls:

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

Results

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

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes35.0ms (0.5%)

Memory

-51.1MiB live, 91.8MiB allocated

Counts

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

Calls

7 calls:

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

Results

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

Compiler

Compiled 32 to 28 computations (12.5% saved)

regimes13.0ms (0.2%)

Memory

37.4MiB live, 37.4MiB allocated

Accuracy

Total -0.0b remaining (-0%)

Threshold costs -0b (-0%)

Counts

3 → 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 re re) (*.f64 #s(literal 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) re) re) (*.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:

2.0ms	(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))
2.0ms	re
2.0ms	im
2.0ms	(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))
2.0ms	(*.f64 im im)

Results

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

Compiler

Compiled 32 to 28 computations (12.5% saved)

simplify79.0ms (1%)

Memory

-24.8MiB live, 53.4MiB allocated

Algorithm

1×	egg-herbie

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	63	268
1	80	268
2	88	268
3	95	268
4	98	268
5	99	268

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

soundness1.5s (19%)

Memory

12.5MiB live, 1 029.6MiB 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	46	381
0	66	393
1	219	361
2	1302	361
3	7310	361
0	8562	326
0	186	1076
1	510	1054
2	1532	1044
3	5373	1010
0	8233	932
0	124	5733
1	289	5603
2	733	5563
3	1746	5563
4	4678	5563
0	8230	5323
0	23	117
0	30	117
1	104	117
2	725	107
3	7021	107
0	8660	90
0	7	30
0	12	30
1	31	30
2	199	30
3	1798	30
0	8149	19

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

Compiler

Compiled 315 to 229 computations (27.3% saved)

preprocess286.0ms (3.7%)

Memory

-9.3MiB live, 302.4MiB allocated

Remove

(sort re im)

(abs re)

(abs im)

Compiler

Compiled 378 to 278 computations (26.5% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated

start0.0ms (0%)

analyze80.0ms (1%)

sample980.0ms (12.8%)

explain265.0ms (3.5%)

preprocess16.0ms (0.2%)

eval0.0ms (0%)

prune0.0ms (0%)

simplify35.0ms (0.5%)

localize28.0ms (0.4%)

series11.0ms (0.1%)

simplify157.0ms (2.1%)

rewrite510.0ms (6.7%)

eval76.0ms (1%)

prune9.0ms (0.1%)

simplify5.0ms (0.1%)

localize65.0ms (0.8%)

series84.0ms (1.1%)

simplify186.0ms (2.4%)

rewrite261.0ms (3.4%)

eval170.0ms (2.2%)

prune50.0ms (0.7%)

simplify5.0ms (0.1%)

localize59.0ms (0.8%)

series48.0ms (0.6%)

simplify189.0ms (2.5%)

rewrite231.0ms (3%)

eval104.0ms (1.4%)

prune53.0ms (0.7%)

simplify203.0ms (2.6%)

localize119.0ms (1.6%)

series58.0ms (0.8%)

simplify376.0ms (4.9%)

rewrite181.0ms (2.4%)

eval214.0ms (2.8%)

prune155.0ms (2%)

regimes177.0ms (2.3%)

regimes125.0ms (1.6%)

regimes149.0ms (2%)

regimes142.0ms (1.9%)

regimes84.0ms (1.1%)

regimes59.0ms (0.8%)

regimes39.0ms (0.5%)

regimes27.0ms (0.4%)

regimes35.0ms (0.5%)

regimes13.0ms (0.2%)

simplify79.0ms (1%)

soundness1.5s (19%)

preprocess286.0ms (3.7%)

end0.0ms (0%)

Profiling