Metrics for math.log10 on complex, real part

start0.0ms (0%)

Memory: 0.1MiB live, 0.1MiB allocated; 0ms collecting garbage

analyze68.0ms (2.6%)

Memory

8.3MiB live, 151.6MiB allocated; 35ms collecting garbage

Algorithm

1×

Search

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

Compiler

Compiled 14 to 9 computations (35.7% saved)

sample918.0ms (35.3%)

Memory

1.2MiB live, 1 397.4MiB allocated; 244ms collecting garbage

Samples

729.0ms

8 256×

valid

Precisions

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

ival-hypot: 198.0ms (52.2% of total)

ival-log: 128.0ms (33.8% of total)

ival-div!: 52.0ms (13.7% of total)

adjust: 2.0ms (0.5% of total)

Bogosity

explain164.0ms (6.3%)

Memory

-1.8MiB live, 191.7MiB allocated; 8ms collecting garbage

FPErrors

Click to see full error table

Ground Truth	Example	Underpredictions	Example	Subexpression
122	-	2	(-2.918802070263346e-203 2.4556213925469152e-157)	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`
0	-	0	-	`(log.f64 #s(literal 10 binary64))`
0	-	0	-	`(/.f64 (log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))) (log.f64 #s(literal 10 binary64)))`
0	-	0	-	`(*.f64 re re)`
0	-	0	-	`im`
0	-	0	-	`(+.f64 (.f64 re re) (.f64 im im))`
0	-	0	-	`re`
0	-	0	-	`(*.f64 im im)`
0	-	0	-	`#s(literal 10 binary64)`
0	-	0	-	`(log.f64 (sqrt.f64 (+.f64 (.f64 re re) (.f64 im im))))`

Explanations

Click to see full explanations table

Operator	Subexpression	Explanation	Count
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	oflow-rescue	105	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	overflow	105
↳	`(*.f64 re re)`	overflow	59
↳	`(*.f64 im im)`	overflow	61
`sqrt.f64`	`(sqrt.f64 (+.f64 (.f64 re re) (.f64 im im)))`	uflow-rescue	15	0
↳	`(+.f64 (.f64 re re) (.f64 im im))`	underflow	15
↳	`(*.f64 re re)`	underflow	63
↳	`(*.f64 im im)`	underflow	63

Confusion

	Predicted +	Predicted -
+	120	2
-	0	134

Precision

1.0

Recall

0.9836065573770492

Confusion?

	Predicted +	Predicted Maybe	Predicted -
+	120	0	2
-	0	0	134

Precision?

1.0

Recall?

0.9836065573770492

Freqs

test

number	freq
0	136
1	120

Total Confusion?

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

Precision?

1.0

Recall?

1.0

Samples

55.0ms

512×

valid

Compiler

Compiled 110 to 34 computations (69.1% saved)

Precisions

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

ival-add!: 18.0ms (45.6% of total)

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

ival-log: 5.0ms (12.7% of total)

ival-mult!: 5.0ms (12.7% of total)

ival-div!: 2.0ms (5.1% of total)

adjust: 0.0ms (0% of total)

preprocess8.0ms (0.3%)

Memory

14.0MiB live, 14.0MiB allocated; 0ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	28	74
1	60	74
2	110	74
3	135	74
4	173	74

Stop Event

1×

saturated

Alt Table

Click to see full alt table

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

Symmetry

(abs re)

(abs im)

(sort re im)

Compiler

Compiled 24 to 20 computations (16.7% saved)

series34.0ms (1.3%)

Memory

-20.5MiB live, 26.7MiB allocated; 2ms collecting garbage

Counts

10 → 79

Calls

Call 1

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

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

Calls

6 calls:

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

rewrite213.0ms (8.2%)

Memory

1.1MiB live, 377.9MiB allocated; 29ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	360	2530
0	371	2390
1	2012	2358
0	9623	1900

Stop Event

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

Counts

89 → 221

Calls

Call 1

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

Outputs
(/.f64 (neg.f64 (neg.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))))) (neg.f64 (log.f64 #s(literal 1/10 binary64))))
(/.f64 (neg.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))
(log.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))))
(pow.f64 (sqrt.f64 (fma.f64 im im (*.f64 re re))) #s(literal 1 binary64))
(pow.f64 (fma.f64 im im (*.f64 re re)) #s(literal 1/2 binary64))
(/.f64 (sqrt.f64 (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im)))) (sqrt.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (sqrt.f64 (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re)))) (sqrt.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (sqrt.f64 (fma.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)))) (sqrt.f64 (fma.f64 (.f64 re re) (.f64 re re) (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (*.f64 im im))))))
(/.f64 (sqrt.f64 (fma.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)))) (sqrt.f64 (fma.f64 (.f64 im im) (.f64 im im) (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (*.f64 re re))))))
(sqrt.f64 (fma.f64 im im (*.f64 re re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (neg.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (neg.f64 im)) re)
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (neg.f64 (fabs.f64 im)) re)
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (neg.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (neg.f64 re)) im)
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (neg.f64 (fabs.f64 re)) im)
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (neg.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 re))
(hypot.f64 (fabs.f64 (fabs.f64 im)) re)
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (neg.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 im))
(hypot.f64 (fabs.f64 (fabs.f64 re)) im)
(hypot.f64 (neg.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (neg.f64 im) (neg.f64 re))
(hypot.f64 (neg.f64 im) (fabs.f64 re))
(hypot.f64 (neg.f64 im) re)
(hypot.f64 (neg.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (neg.f64 re) (neg.f64 im))
(hypot.f64 (neg.f64 re) (fabs.f64 im))
(hypot.f64 (neg.f64 re) im)
(hypot.f64 (fabs.f64 im) (neg.f64 (neg.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (fabs.f64 (fabs.f64 re)))
(hypot.f64 (fabs.f64 im) (neg.f64 re))
(hypot.f64 (fabs.f64 im) (fabs.f64 re))
(hypot.f64 (fabs.f64 im) re)
(hypot.f64 (fabs.f64 re) (neg.f64 (neg.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (fabs.f64 (fabs.f64 im)))
(hypot.f64 (fabs.f64 re) (neg.f64 im))
(hypot.f64 (fabs.f64 re) (fabs.f64 im))
(hypot.f64 (fabs.f64 re) im)
(hypot.f64 im (neg.f64 (neg.f64 re)))
(hypot.f64 im (neg.f64 (fabs.f64 re)))
(hypot.f64 im (fabs.f64 (fabs.f64 re)))
(hypot.f64 im (neg.f64 re))
(hypot.f64 im (fabs.f64 re))
(hypot.f64 im re)
(hypot.f64 re (neg.f64 (neg.f64 im)))
(hypot.f64 re (neg.f64 (fabs.f64 im)))
(hypot.f64 re (fabs.f64 (fabs.f64 im)))
(hypot.f64 re (neg.f64 im))
(hypot.f64 re (fabs.f64 im))
(hypot.f64 re im)
(exp.f64 (.f64 (log.f64 (fma.f64 im im (.f64 re re))) #s(literal 1/2 binary64)))
(/.f64 (neg.f64 (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im)))) (neg.f64 (-.f64 (.f64 re re) (.f64 im im))))
(/.f64 (neg.f64 (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re)))) (neg.f64 (-.f64 (.f64 im im) (.f64 re re))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)))) (neg.f64 (fma.f64 (.f64 re re) (.f64 re re) (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (*.f64 im im))))))
(/.f64 (neg.f64 (fma.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)))) (neg.f64 (fma.f64 (.f64 im im) (.f64 im im) (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (*.f64 re re))))))
(/.f64 (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) (-.f64 (.f64 re re) (.f64 im im)))
(/.f64 (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) (-.f64 (.f64 im im) (.f64 re re)))
(/.f64 (fma.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) (fma.f64 (.f64 re re) (.f64 re re) (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (*.f64 im im)))))
(/.f64 (fma.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (fma.f64 (.f64 im im) (.f64 im im) (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (*.f64 re re)))))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)) (*.f64 re re))
(fma.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(fma.f64 re re (*.f64 im im))
(-.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (-.f64 (.f64 re re) (.f64 im im))) (/.f64 (.f64 (.f64 im im) (.f64 im im)) (-.f64 (.f64 re re) (.f64 im im))))
(-.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (-.f64 (.f64 im im) (.f64 re re))) (/.f64 (.f64 (.f64 re re) (.f64 re re)) (-.f64 (.f64 im im) (.f64 re re))))
(-.f64 (.f64 re re) (.f64 (neg.f64 im) im))
(+.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (fma.f64 (.f64 re re) (.f64 re re) (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 im im))))) (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (fma.f64 (.f64 re re) (.f64 re re) (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 im im))))))
(+.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (fma.f64 (.f64 im im) (.f64 im im) (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 re re))))) (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (fma.f64 (.f64 im im) (.f64 im im) (-.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 re re))))))
(+.f64 (.f64 im im) (.f64 re re))
(+.f64 (.f64 re re) (.f64 im im))
(*.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)))
(*.f64 (neg.f64 (fabs.f64 re)) (neg.f64 (fabs.f64 re)))
(*.f64 (fabs.f64 (fabs.f64 re)) (fabs.f64 (fabs.f64 re)))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 re re)
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 re #s(literal 2 binary64))
(fabs.f64 (*.f64 re re))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))))
re
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(*.f64 (neg.f64 (fabs.f64 im)) (neg.f64 (fabs.f64 im)))
(*.f64 (fabs.f64 (fabs.f64 im)) (fabs.f64 (fabs.f64 im)))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 im im)
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 (fabs.f64 im) #s(literal 2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(fabs.f64 (*.f64 im im))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))))
im
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 re re)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64))))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 10 binary64))))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 im im) (.f64 im im)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) im)
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) im)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/16 binary64) (.f64 re re)) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 im im) im))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
#s(approx (+ (* re re) (* im im)) (fma.f64 im im (*.f64 re re)))
#s(approx (* re re) (*.f64 re re))
#s(approx re re)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) re)
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64)) re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
#s(approx (+ (* re re) (* im im)) (.f64 (+.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 10 binary64)))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 im im)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) (.f64 re re)) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 re))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (.f64 re re))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im) (log.f64 re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 im im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 re re) (.f64 re re)))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (log.f64 re)))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) re)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (sqrt (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/16 binary64) (.f64 im im)) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 re re) re))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (* im im) (*.f64 im im))
#s(approx im im)
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (log.f64 im))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im))) (log.f64 im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) (log.f64 im)))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))) #s(literal 1 binary64)) im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) #s(literal 1 binary64)) im))
#s(approx (+ (* re re) (* im im)) (.f64 (+.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))) #s(literal 1/2 binary64) (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) (+.f64 (neg.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 10 binary64)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 (.f64 im im) (.f64 im im)) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (*.f64 im im) (log.f64 #s(literal 10 binary64))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))))))
#s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))) #s(literal 1 binary64))))
#s(approx (sqrt (+ (* re re) (* im im))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 re re) (.f64 re re)) (.f64 (.f64 im im) (.f64 im im))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) #s(literal 1 binary64))))

eval24.0ms (0.9%)

Memory: 17.4MiB live, 64.1MiB allocated; 2ms collecting garbage
Compiler: Compiled 4 815 to 905 computations (81.2% saved)

prune10.0ms (0.4%)

Memory

-28.4MiB live, 24.9MiB allocated; 4ms collecting garbage

Pruning

8 alts after pruning (8 fresh and 0 done)

	Pruned	Kept	Total
New	200	8	208
Fresh	0	0	0
Picked	1	0	1
Done	0	0	0
Total	201	8	209

Accuracy

99.4%

Counts

209 → 8

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	54.1%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
	54.0%	(/.f64 (neg.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
▶	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶	25.8%	(/.f64 (log.f64 (/.f64 (sqrt.f64 (-.f64 (.f64 (.f64 im im) (.f64 im im)) (.f64 (.f64 re re) (.f64 re re)))) (sqrt.f64 (-.f64 (.f64 im im) (.f64 re re))))) (log.f64 #s(literal 10 binary64)))
	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
▶	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
	10.5%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) re)) (log.f64 #s(literal 10 binary64)))
▶	98.8%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 238 to 178 computations (25.2% saved)

series40.0ms (1.6%)

Memory

34.8MiB live, 118.5MiB allocated; 10ms collecting garbage

Counts

30 → 272

Calls

Call 1

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

Outputs
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log im)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 im))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ 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)))))))
#s(approx re #s(hole binary64 re))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* 1/2 (/ (log (pow im 2)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow im 2)) (log 10))) (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* 1/2 (log (pow im 2)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole 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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (log (pow im 2))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (log im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (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))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ 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)))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (pow im 2)))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* -1/2 (/ (pow re 4) (pow im 2))) (pow im 2))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* (pow re 4) (- (* -1/8 (/ (pow re 4) (pow im 6))) (* 1/2 (/ 1 (pow im 2))))) (pow im 2))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* (pow re 4) (- (* (pow re 4) (- (* -1/16 (/ (pow re 4) (pow im 10))) (* 1/8 (/ 1 (pow im 6))))) (* 1/2 (/ 1 (pow im 2))))) (pow im 2))))
#s(approx (- (* (* im im) (* im im)) (* (* re re) (* re re))) #s(hole binary64 (pow im 4)))
#s(approx (- (* (* im im) (* im im)) (* (* re re) (* re re))) #s(hole binary64 (+ (* -1 (pow re 4)) (pow im 4))))
#s(approx (* (* re re) (* re re)) #s(hole binary64 (pow re 4)))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 im))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ im (* -1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ im (* (pow re 2) (- (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ 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)))))))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (+ (* -1 (pow re 2)) (pow im 2))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 re))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ 1 re)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* 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)))))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow re 2) (sqrt -1))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow re 2) (+ (sqrt -1) (* 1/2 (/ (pow im 4) (* (pow re 4) (sqrt -1))))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow re 2) (+ (sqrt -1) (+ (* -1/8 (/ (pow im 8) (* (pow re 8) (pow (sqrt -1) 3)))) (* 1/2 (/ (pow im 4) (* (pow re 4) (sqrt -1)))))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow re 2) (+ (sqrt -1) (+ (* -1/8 (/ (pow im 8) (* (pow re 8) (pow (sqrt -1) 3)))) (+ (* 1/16 (/ (pow im 12) (* (pow re 12) (pow (sqrt -1) 5)))) (* 1/2 (/ (pow im 4) (* (pow re 4) (sqrt -1))))))))))
#s(approx (- (* (* im im) (* im im)) (* (* re re) (* re re))) #s(hole binary64 (* -1 (pow re 4))))
#s(approx (- (* (* im im) (* im im)) (* (* re re) (* re re))) #s(hole binary64 (* (pow re 4) (- (/ (pow im 4) (pow re 4)) 1))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* re (sqrt -1))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* re (+ (sqrt -1) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* re (+ (sqrt -1) (+ (* -1/8 (/ (pow im 4) (* (pow re 4) (pow (sqrt -1) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1)))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* re (+ (sqrt -1) (+ (* -1/8 (/ (pow im 4) (* (pow re 4) (pow (sqrt -1) 3)))) (+ (* 1/16 (/ (pow im 6) (* (pow re 6) (pow (sqrt -1) 5)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1))))))))))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (* -1 (pow re 2))))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (- (/ (pow im 2) (pow re 2)) 1))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 re)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/6 (/ (pow im 6) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ -1 re)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 re)))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* re (sqrt -1)))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ (sqrt -1) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1)))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ (sqrt -1) (+ (* -1/8 (/ (pow im 4) (* (pow re 4) (pow (sqrt -1) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1))))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ (sqrt -1) (+ (* -1/8 (/ (pow im 4) (* (pow re 4) (pow (sqrt -1) 3)))) (+ (* 1/16 (/ (pow im 6) (* (pow re 6) (pow (sqrt -1) 5)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1)))))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (log re)))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (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))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (+ 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)))))))
#s(approx im #s(hole binary64 im))
#s(approx (neg im) #s(hole binary64 (* -1 im)))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* 1/2 (/ (log (pow re 2)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (log (pow re 2)) (log 10))) (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* 1/2 (log (pow re 2)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole 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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (log (pow re 2))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (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)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (log re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (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))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ 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)))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* 1/2 (/ (pow im 4) (* (pow re 2) (sqrt -1)))) (* (pow re 2) (sqrt -1)))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* (pow im 4) (+ (* -1/8 (/ (pow im 4) (* (pow re 6) (pow (sqrt -1) 3)))) (* 1/2 (/ 1 (* (pow re 2) (sqrt -1)))))) (* (pow re 2) (sqrt -1)))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* (pow im 4) (+ (* (pow im 4) (- (* 1/16 (/ (pow im 4) (* (pow re 10) (pow (sqrt -1) 5)))) (* 1/8 (/ 1 (* (pow re 6) (pow (sqrt -1) 3)))))) (* 1/2 (/ 1 (* (pow re 2) (sqrt -1)))))) (* (pow re 2) (sqrt -1)))))
#s(approx (- (* (* im im) (* im im)) (* (* re re) (* re re))) #s(hole binary64 (- (pow im 4) (pow re 4))))
#s(approx (* (* im im) (* im im)) #s(hole binary64 (pow im 4)))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* re (sqrt -1)))) (* re (sqrt -1)))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ (* re (sqrt -1)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (* (pow re 3) (pow (sqrt -1) 3)))) (* 1/2 (/ 1 (* re (sqrt -1)))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ (* re (sqrt -1)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (* (pow re 5) (pow (sqrt -1) 5)))) (* 1/8 (/ 1 (* (pow re 3) (pow (sqrt -1) 3)))))) (* 1/2 (/ 1 (* re (sqrt -1)))))))))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (- (pow im 2) (pow re 2))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* 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)))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ 1 im)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* 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)))))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow im 2) (+ 1 (* -1/2 (/ (pow re 4) (pow im 4)))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow im 2) (+ 1 (+ (* -1/2 (/ (pow re 4) (pow im 4))) (* -1/8 (/ (pow re 8) (pow im 8))))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow im 2) (+ 1 (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* -1/8 (/ (pow re 8) (pow im 8))) (* -1/16 (/ (pow re 12) (pow im 12)))))))))
#s(approx (- (* (* im im) (* im im)) (* (* re re) (* re re))) #s(hole binary64 (* (pow im 4) (+ 1 (* -1 (/ (pow re 4) (pow im 4)))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (* -1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* -1/8 (/ (pow re 4) (pow im 4))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* -1/16 (/ (pow re 6) (pow im 6)))))))))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (* (pow im 2) (+ 1 (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (sqrt (+ (* re re) (* im im)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (sqrt (+ (* re re) (* im im)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (sqrt (+ (* re re) (* im im))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (* 1/2 (log (+ (* im im) (* re re)))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/6 (/ (pow re 6) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ -1 im)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 im)))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (* -1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* -1/8 (/ (pow re 4) (pow im 4)))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* -1/16 (/ (pow re 6) (pow im 6))))))))))

Calls

6 calls:

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

rewrite254.0ms (9.8%)

Memory

7.4MiB live, 275.7MiB allocated; 125ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	846	9963
0	897	7477
0	4440	7174

Stop Event

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

Counts

302 → 449

Calls

Call 1

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

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

eval33.0ms (1.3%)

Memory: 16.3MiB live, 66.4MiB allocated; 7ms collecting garbage
Compiler: Compiled 13 440 to 1 700 computations (87.4% saved)

prune10.0ms (0.4%)

Memory

-25.3MiB live, 21.5MiB allocated; 3ms collecting garbage

Pruning

9 alts after pruning (5 fresh and 4 done)

	Pruned	Kept	Total
New	332	4	336
Fresh	2	1	3
Picked	1	4	5
Done	0	0	0
Total	335	9	344

Accuracy

99.4%

Counts

344 → 9

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	54.1%	(/.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re)))) (log.f64 #s(literal 10 binary64)))
▶	54.0%	(/.f64 (neg.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 im im (.f64 re re))))) (log.f64 #s(literal 1/10 binary64)))
✓	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
▶	52.6%	(/.f64 (log.f64 (/.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im)) (sqrt.f64 (-.f64 (.f64 im im) (*.f64 re re))))) (log.f64 #s(literal 10 binary64)))
▶	0.0%	(/.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
▶	10.5%	(/.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
✓	98.8%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶	0.0%	(/.f64 #s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg.f64 (log.f64 (/.f64 #s(literal -1 binary64) re)))) (log.f64 #s(literal 10 binary64)))

Compiler

Compiled 336 to 204 computations (39.3% saved)

series120.0ms (4.6%)

Memory

33.0MiB live, 127.5MiB allocated; 72ms collecting garbage

Counts

33 → 225

Calls

Call 1

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

Outputs
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1/2 (/ (log (pow im 2)) (log 1/10)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* 1/4 (/ (pow re 2) (* (pow im 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (log (pow im 2)) (log 1/10))) (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (* (pow im 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow im 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 1/10)))))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (* -1/2 (log (pow im 2)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* 1/2 (log (pow im 2))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow re 2) (- (* 1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))) (* 1/2 (log (pow im 2))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow re 2) (- (* (pow re 2) (+ (* -1/6 (/ (pow re 2) (pow im 6))) (* 1/4 (/ 1 (pow im 4))))) (* 1/2 (/ 1 (pow im 2))))) (* 1/2 (log (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* 1/2 (log (pow im 2)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow im 2))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow im 2))) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole 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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (log (pow im 2))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow im 2)) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow im 2)) (* (pow re 2) (+ (* -1/2 (/ (pow re 2) (pow im 4))) (/ 1 (pow im 2)))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (+ (pow im 2) (pow re 2))))
#s(approx (* re re) #s(hole binary64 (pow re 2)))
#s(approx re #s(hole binary64 re))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (/ (log im) (log 10))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))) (/ (log im) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (* (pow im 4) (log 10)))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* (pow re 2) (+ (* (pow re 2) (- (* 1/6 (/ (pow re 2) (* (pow im 6) (log 10)))) (* 1/4 (/ 1 (* (pow im 4) (log 10)))))) (* 1/2 (/ 1 (* (pow im 2) (log 10)))))) (/ (log im) (log 10)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (log im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (log im) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (log im) (* (pow re 2) (+ (* -1/4 (/ (pow re 2) (pow im 4))) (* 1/2 (/ 1 (pow im 2))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (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))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ im (* 1/2 (/ (pow re 2) im)))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ im (* (pow re 2) (+ (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ 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)))))))
#s(approx (neg re) #s(hole binary64 (* -1 re)))
#s(approx (neg (log (/ -1 re))) #s(hole binary64 (* -1 (+ (log -1) (* -1 (log re))))))
#s(approx (log (/ -1 re)) #s(hole binary64 (+ (log -1) (* -1 (log re)))))
#s(approx (/ -1 re) #s(hole binary64 (/ -1 re)))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (pow im 2)))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* -1/2 (/ (pow re 4) (pow im 2))) (pow im 2))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* (pow re 4) (- (* -1/8 (/ (pow re 4) (pow im 6))) (* 1/2 (/ 1 (pow im 2))))) (pow im 2))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* (pow re 4) (- (* (pow re 4) (- (* -1/16 (/ (pow re 4) (pow im 10))) (* 1/8 (/ 1 (pow im 6))))) (* 1/2 (/ 1 (pow im 2))))) (pow im 2))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 im))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ im (* -1/2 (/ (pow re 2) im)))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ im (* (pow re 2) (- (* -1/8 (/ (pow re 2) (pow im 3))) (* 1/2 (/ 1 im)))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ 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)))))))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (pow im 2)))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (+ (* -1 (pow re 2)) (pow im 2))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 re)) (log 1/10))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ 1 re)) (log 1/10)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ 1 re))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/6 (/ (pow im 6) (pow re 6))) (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ 1 re)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 re))) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (pow re 2)))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (+ 1 (/ (pow im 2) (pow re 2))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 re)) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (* -1 (log (/ 1 re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* 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)))))))))
#s(approx (neg (log (/ -1 re))) #s(hole binary64 (* -1 (+ (log -1) (log (/ 1 re))))))
#s(approx (log (/ -1 re)) #s(hole binary64 (+ (log -1) (log (/ 1 re)))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow re 2) (sqrt -1))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow re 2) (+ (sqrt -1) (* 1/2 (/ (pow im 4) (* (pow re 4) (sqrt -1))))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow re 2) (+ (sqrt -1) (+ (* -1/8 (/ (pow im 8) (* (pow re 8) (pow (sqrt -1) 3)))) (* 1/2 (/ (pow im 4) (* (pow re 4) (sqrt -1)))))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow re 2) (+ (sqrt -1) (+ (* -1/8 (/ (pow im 8) (* (pow re 8) (pow (sqrt -1) 3)))) (+ (* 1/16 (/ (pow im 12) (* (pow re 12) (pow (sqrt -1) 5)))) (* 1/2 (/ (pow im 4) (* (pow re 4) (sqrt -1))))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* re (sqrt -1))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* re (+ (sqrt -1) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* re (+ (sqrt -1) (+ (* -1/8 (/ (pow im 4) (* (pow re 4) (pow (sqrt -1) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1)))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* re (+ (sqrt -1) (+ (* -1/8 (/ (pow im 4) (* (pow re 4) (pow (sqrt -1) 3)))) (+ (* 1/16 (/ (pow im 6) (* (pow re 6) (pow (sqrt -1) 5)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1))))))))))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (* -1 (pow re 2))))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (* (pow re 2) (- (/ (pow im 2) (pow re 2)) 1))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 re)) (log 1/10))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))) (+ (* -1/6 (/ (pow im 6) (* (pow re 6) (log 1/10)))) (+ (* 1/4 (/ (pow im 4) (* (pow re 4) (log 1/10)))) (/ (log (/ -1 re)) (log 1/10)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* -1 (log (/ -1 re))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow im 4) (pow re 4))) (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/6 (/ (pow im 6) (pow re 6))) (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ -1 re)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 re))) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 re))) (+ (* -1/2 (/ (pow im 4) (pow re 4))) (/ (pow im 2) (pow re 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 re)) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10))))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 re)) (log 10))) (+ (* -1/4 (/ (pow im 4) (* (pow re 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (* (pow re 6) (log 10)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 re))) (+ (* -1/4 (/ (pow im 4) (pow re 4))) (+ (* 1/720 (/ (+ (* 30 (pow im 6)) (* 90 (pow im 6))) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 re)))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* re (+ 1 (* 1/2 (/ (pow im 2) (pow re 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (* 1/2 (/ (pow im 2) (pow re 2)))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* re (+ 1 (+ (* -1/8 (/ (pow im 4) (pow re 4))) (+ (* 1/16 (/ (pow im 6) (pow re 6))) (* 1/2 (/ (pow im 2) (pow re 2))))))))))
#s(approx (neg (log (/ -1 re))) #s(hole binary64 (* -1 (log (/ -1 re)))))
#s(approx (log (/ -1 re)) #s(hole binary64 (log (/ -1 re))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* re (sqrt -1)))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ (sqrt -1) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1)))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ (sqrt -1) (+ (* -1/8 (/ (pow im 4) (* (pow re 4) (pow (sqrt -1) 3)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1))))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* re (+ (sqrt -1) (+ (* -1/8 (/ (pow im 4) (* (pow re 4) (pow (sqrt -1) 3)))) (+ (* 1/16 (/ (pow im 6) (* (pow re 6) (pow (sqrt -1) 5)))) (* 1/2 (/ (pow im 2) (* (pow re 2) (sqrt -1)))))))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (* -1/2 (/ (log (pow re 2)) (log 1/10)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* -1/2 (/ (pow im 2) (* (pow re 2) (log 1/10)))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* 1/4 (/ (pow im 2) (* (pow re 4) (log 1/10)))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (log (pow re 2)) (log 1/10))) (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (* (pow re 6) (log 1/10)))) (* 1/4 (/ 1 (* (pow re 4) (log 1/10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 1/10)))))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (* -1/2 (log (pow re 2)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow im 2) (pow re 2))) (* 1/2 (log (pow re 2))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow im 2) (- (* 1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))) (* 1/2 (log (pow re 2))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* (pow im 2) (- (* (pow im 2) (+ (* -1/6 (/ (pow im 2) (pow re 6))) (* 1/4 (/ 1 (pow re 4))))) (* 1/2 (/ 1 (pow re 2))))) (* 1/2 (log (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* 1/2 (log (pow re 2)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow re 2))) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* 1/2 (log (pow re 2))) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole 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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (log (pow re 2))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow re 2)) (/ (pow im 2) (pow re 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (log (pow re 2)) (* (pow im 2) (+ (* -1/2 (/ (pow im 2) (pow re 4))) (/ 1 (pow re 2)))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (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)))))))
#s(approx im #s(hole binary64 im))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (/ (log re) (log 10))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* (pow re 2) (log 10)))) (/ (log re) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (* (pow re 4) (log 10)))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* (pow im 2) (+ (* (pow im 2) (- (* 1/6 (/ (pow im 2) (* (pow re 6) (log 10)))) (* 1/4 (/ 1 (* (pow re 4) (log 10)))))) (* 1/2 (/ 1 (* (pow re 2) (log 10)))))) (/ (log re) (log 10)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (log re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (log re) (* 1/2 (/ (pow im 2) (pow re 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (log re) (* (pow im 2) (+ (* -1/4 (/ (pow im 2) (pow re 4))) (* 1/2 (/ 1 (pow re 2))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (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))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ re (* 1/2 (/ (pow im 2) re)))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ re (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (pow re 3))) (* 1/2 (/ 1 re)))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (+ 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)))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* 1/2 (/ (pow im 4) (* (pow re 2) (sqrt -1)))) (* (pow re 2) (sqrt -1)))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* (pow im 4) (+ (* -1/8 (/ (pow im 4) (* (pow re 6) (pow (sqrt -1) 3)))) (* 1/2 (/ 1 (* (pow re 2) (sqrt -1)))))) (* (pow re 2) (sqrt -1)))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (+ (* (pow im 4) (+ (* (pow im 4) (- (* 1/16 (/ (pow im 4) (* (pow re 10) (pow (sqrt -1) 5)))) (* 1/8 (/ 1 (* (pow re 6) (pow (sqrt -1) 3)))))) (* 1/2 (/ 1 (* (pow re 2) (sqrt -1)))))) (* (pow re 2) (sqrt -1)))))
#s(approx (* im im) #s(hole binary64 (pow im 2)))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ (* 1/2 (/ (pow im 2) (* re (sqrt -1)))) (* re (sqrt -1)))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ (* re (sqrt -1)) (* (pow im 2) (+ (* -1/8 (/ (pow im 2) (* (pow re 3) (pow (sqrt -1) 3)))) (* 1/2 (/ 1 (* re (sqrt -1)))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (+ (* re (sqrt -1)) (* (pow im 2) (+ (* (pow im 2) (- (* 1/16 (/ (pow im 2) (* (pow re 5) (pow (sqrt -1) 5)))) (* 1/8 (/ 1 (* (pow re 3) (pow (sqrt -1) 3)))))) (* 1/2 (/ 1 (* re (sqrt -1)))))))))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (- (pow im 2) (pow re 2))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ 1 im)) (log 1/10))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ 1 im)) (log 1/10)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (log (/ 1 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ 1 im))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/6 (/ (pow re 6) (pow im 6))) (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ 1 im)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 im))) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ 1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (+ (* im im) (* re re)) #s(hole binary64 (* (pow im 2) (+ 1 (/ (pow re 2) (pow im 2))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ 1 im)) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ 1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (* -1 (log (/ 1 im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ 1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* 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)))))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow im 2) (+ 1 (* -1/2 (/ (pow re 4) (pow im 4)))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow im 2) (+ 1 (+ (* -1/2 (/ (pow re 4) (pow im 4))) (* -1/8 (/ (pow re 8) (pow im 8))))))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) #s(hole binary64 (* (pow im 2) (+ 1 (+ (* -1/2 (/ (pow re 4) (pow im 4))) (+ (* -1/8 (/ (pow re 8) (pow im 8))) (* -1/16 (/ (pow re 12) (pow im 12)))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (* -1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* -1/8 (/ (pow re 4) (pow im 4))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* im (+ 1 (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* -1/16 (/ (pow re 6) (pow im 6)))))))))
#s(approx (- (* im im) (* re re)) #s(hole binary64 (* (pow im 2) (+ 1 (* -1 (/ (pow re 2) (pow im 2)))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (/ (log (/ -1 im)) (log 1/10))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) #s(hole binary64 (+ (* -1/2 (/ (pow re 2) (* (pow im 2) (log 1/10)))) (+ (* -1/6 (/ (pow re 6) (* (pow im 6) (log 1/10)))) (+ (* 1/4 (/ (pow re 4) (* (pow im 4) (log 1/10)))) (/ (log (/ -1 im)) (log 1/10)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (log (/ -1 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/2 (/ (pow re 2) (pow im 2))) (* -1 (log (/ -1 im))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* 1/4 (/ (pow re 4) (pow im 4))) (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) #s(hole binary64 (- (* -1/6 (/ (pow re 6) (pow im 6))) (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (* 1/2 (log (+ (* im im) (* re re)))) #s(hole binary64 (+ (* -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))))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (* -2 (log (/ -1 im)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 im))) (/ (pow re 2) (pow im 2)))))
#s(approx (log (+ (* im im) (* re re))) #s(hole binary64 (+ (* -2 (log (/ -1 im))) (+ (* -1/2 (/ (pow re 4) (pow im 4))) (/ (pow re 2) (pow im 2))))))
#s(approx (log (+ (* im im) (* re re))) #s(hole 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)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (* -1 (/ (log (/ -1 im)) (log 10)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10))))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) #s(hole binary64 (+ (* -1 (/ (log (/ -1 im)) (log 10))) (+ (* -1/4 (/ (pow re 4) (* (pow im 4) (log 10)))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (* (pow im 6) (log 10)))) (* 1/2 (/ (pow re 2) (* (pow im 2) (log 10)))))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (* -1 (log (/ -1 im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (* 1/2 (/ (pow re 2) (pow im 2))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) #s(hole binary64 (+ (* -1 (log (/ -1 im))) (+ (* -1/4 (/ (pow re 4) (pow im 4))) (+ (* 1/720 (/ (+ (* 30 (pow re 6)) (* 90 (pow re 6))) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 im)))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* im (+ 1 (* 1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* 1/2 (/ (pow re 2) (pow im 2)))))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/8 (/ (pow re 4) (pow im 4))) (+ (* 1/16 (/ (pow re 6) (pow im 6))) (* 1/2 (/ (pow re 2) (pow im 2))))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 im)))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (* -1/2 (/ (pow re 2) (pow im 2))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/2 (/ (pow re 2) (pow im 2))) (* -1/8 (/ (pow re 4) (pow im 4)))))))))
#s(approx (sqrt (- (* im im) (* re re))) #s(hole binary64 (* -1 (* im (+ 1 (+ (* -1/2 (/ (pow re 2) (pow im 2))) (+ (* -1/8 (/ (pow re 4) (pow im 4))) (* -1/16 (/ (pow re 6) (pow im 6))))))))))

Calls

6 calls:

Time	Variable		Point	Expression
64.0ms	re	@	-inf	((/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (neg (* 1/2 (log (+ (* im im) (* re re))))) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) im (* re re) re (log 1/10) 1/10 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (log 10) 10 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg re) (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg (log (/ -1 re))) (log (/ -1 re)) (/ -1 re) -1 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (* im im) (sqrt (- (* im im) (* re re))) (- (* im im) (* re re)))
33.0ms	re	@	0	((/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (neg (* 1/2 (log (+ (* im im) (* re re))))) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) im (* re re) re (log 1/10) 1/10 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (log 10) 10 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg re) (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg (log (/ -1 re))) (log (/ -1 re)) (/ -1 re) -1 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (* im im) (sqrt (- (* im im) (* re re))) (- (* im im) (* re re)))
9.0ms	re	@	inf	((/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (neg (* 1/2 (log (+ (* im im) (* re re))))) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) im (* re re) re (log 1/10) 1/10 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (log 10) 10 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg re) (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg (log (/ -1 re))) (log (/ -1 re)) (/ -1 re) -1 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (* im im) (sqrt (- (* im im) (* re re))) (- (* im im) (* re re)))
3.0ms	im	@	inf	((/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (neg (* 1/2 (log (+ (* im im) (* re re))))) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) im (* re re) re (log 1/10) 1/10 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (log 10) 10 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg re) (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg (log (/ -1 re))) (log (/ -1 re)) (/ -1 re) -1 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (* im im) (sqrt (- (* im im) (* re re))) (- (* im im) (* re re)))
3.0ms	im	@	0	((/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (neg (* 1/2 (log (+ (* im im) (* re re))))) (* 1/2 (log (+ (* im im) (* re re)))) 1/2 (log (+ (* im im) (* re re))) (+ (* im im) (* re re)) im (* re re) re (log 1/10) 1/10 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (log 10) 10 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg re) (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg (log (/ -1 re))) (log (/ -1 re)) (/ -1 re) -1 (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (* im im) (sqrt (- (* im im) (* re re))) (- (* im im) (* re re)))

rewrite199.0ms (7.7%)

Memory

-18.2MiB live, 261.3MiB allocated; 30ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	898	8804
0	937	6948
1	5079	6660
0	8763	5803

Stop Event

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

Counts

258 → 350

Calls

Call 1

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

Outputs
(/.f64 (neg.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(neg.f64 (/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 #s(literal 1/2 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))))
(neg.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)))
(log.f64 (pow.f64 (fma.f64 re re (*.f64 im im)) #s(literal -1/2 binary64)))
(log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64))
(.f64 #s(literal 1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
(-.f64 (log.f64 (neg.f64 (sqrt.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 im re) (-.f64 im re)))))) (log.f64 (neg.f64 (sqrt.f64 (.f64 (+.f64 im re) (-.f64 im re))))))
(-.f64 (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 im re) (-.f64 im re))))) (.f64 #s(literal 1/2 binary64) (log.f64 (.f64 (+.f64 im re) (-.f64 im re)))))
(log.f64 (sqrt.f64 (fma.f64 re re (*.f64 im im))))
#s(literal 1/2 binary64)
(-.f64 (log.f64 (fma.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)))) (log.f64 (fma.f64 (.f64 (.f64 im im) im) im (-.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 im im) (*.f64 re re))))))
(-.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 im re) (-.f64 im re)))) (log.f64 (.f64 (+.f64 im re) (-.f64 im re))))
(log.f64 (fma.f64 re re (*.f64 im im)))
(/.f64 (fma.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (fma.f64 (.f64 (.f64 im im) im) im (-.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 im im) (*.f64 re re)))))
(/.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 im re) (-.f64 im re))) (.f64 (+.f64 im re) (-.f64 im re)))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (fabs.f64 re) (fabs.f64 re) (*.f64 im im))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 re re))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 re re (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(-.f64 (.f64 im im) (.f64 (neg.f64 re) re))
(+.f64 (.f64 re re) (.f64 im im))
(+.f64 (.f64 im im) (.f64 re re))
im
(*.f64 (fabs.f64 re) (fabs.f64 re))
(*.f64 (neg.f64 re) (neg.f64 re))
(*.f64 re re)
(pow.f64 (fabs.f64 re) #s(literal 2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal -2 binary64))
(pow.f64 (*.f64 re re) #s(literal 1 binary64))
(pow.f64 (neg.f64 re) #s(literal 2 binary64))
(pow.f64 re #s(literal 2 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 #s(literal 1 binary64) re) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 re) #s(literal 2 binary64))))
re
(neg.f64 (log.f64 #s(literal 10 binary64)))
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)
(neg.f64 (log.f64 #s(literal 1/10 binary64)))
(log.f64 #s(literal 10 binary64))
#s(literal 10 binary64)
(/.f64 (neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
(log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re)))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))
(*.f64 #s(literal -1 binary64) re)
(*.f64 re #s(literal -1 binary64))
(neg.f64 re)
(/.f64 (neg.f64 #s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 #s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))) (log.f64 #s(literal 10 binary64)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
(*.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 (neg.f64 re))))
(neg.f64 (neg.f64 (log.f64 (neg.f64 re))))
(fma.f64 (log.f64 #s(literal -1 binary64)) #s(literal -1 binary64) (log.f64 re))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)) (log.f64 re))
(-.f64 #s(literal 0 binary64) (neg.f64 (log.f64 (neg.f64 re))))
(+.f64 (*.f64 (log.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (log.f64 re))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 re))
(log.f64 (pow.f64 (*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) re)) #s(literal -1 binary64)))
(log.f64 (/.f64 #s(literal 1 binary64) (*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) re))))
(log.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) re)))
(/.f64 (-.f64 (pow.f64 (log.f64 #s(literal -1 binary64)) #s(literal 2 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64))) (log.f64 (/.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) re))))
(/.f64 (+.f64 (pow.f64 (log.f64 #s(literal -1 binary64)) #s(literal 3 binary64)) (pow.f64 (neg.f64 (log.f64 re)) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 #s(literal -1 binary64)) #s(literal 2 binary64)) (-.f64 (pow.f64 (neg.f64 (log.f64 re)) #s(literal 2 binary64)) (*.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 re))))))
(neg.f64 (log.f64 (neg.f64 re)))
(fma.f64 (*.f64 (log.f64 re) #s(literal 2 binary64)) #s(literal -1/2 binary64) (log.f64 #s(literal -1 binary64)))
(fma.f64 (log.f64 re) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal -1/2 binary64) (*.f64 (log.f64 re) #s(literal 2 binary64)) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal -1 binary64) (log.f64 re) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 re)))
(-.f64 #s(literal 0 binary64) (log.f64 (neg.f64 re)))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 re))
(+.f64 (neg.f64 (log.f64 re)) (log.f64 #s(literal -1 binary64)))
(+.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 re)))
(log.f64 (*.f64 (/.f64 #s(literal 1 binary64) re) #s(literal -1 binary64)))
(log.f64 (*.f64 #s(literal -1 binary64) (/.f64 #s(literal 1 binary64) re)))
(log.f64 (/.f64 #s(literal -1 binary64) re))
(pow.f64 (neg.f64 re) #s(literal -1 binary64))
(/.f64 #s(literal 1 binary64) (neg.f64 re))
(/.f64 #s(literal -1 binary64) re)
#s(literal -1 binary64)
(/.f64 (neg.f64 (log.f64 (/.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im)) (sqrt.f64 (.f64 (+.f64 im re) (-.f64 im re)))))) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (log.f64 (/.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im)) (sqrt.f64 (.f64 (+.f64 im re) (-.f64 im re))))) (log.f64 #s(literal 10 binary64)))
(-.f64 (log.f64 (neg.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im)))) (log.f64 (neg.f64 (sqrt.f64 (.f64 (+.f64 im re) (-.f64 im re))))))
(-.f64 (log.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im))) (.f64 #s(literal 1/2 binary64) (log.f64 (*.f64 (+.f64 im re) (-.f64 im re)))))
(log.f64 (/.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im)) (sqrt.f64 (.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 (neg.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im))) (neg.f64 (sqrt.f64 (.f64 (+.f64 im re) (-.f64 im re)))))
(/.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im)) (sqrt.f64 (.f64 (+.f64 im re) (-.f64 im re))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (*.f64 im im))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 (fabs.f64 im) (fabs.f64 im))
(*.f64 im im)
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 (fabs.f64 im) #s(literal 2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) im) #s(literal -2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 #s(literal 1 binary64) im) #s(literal 2 binary64)))
(exp.f64 (*.f64 (log.f64 im) #s(literal 2 binary64)))
(+.f64 (cosh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))) (sinh.f64 (.f64 (log.f64 im) #s(literal 2 binary64))))
(*.f64 (pow.f64 (+.f64 im re) #s(literal 1/2 binary64)) (pow.f64 (-.f64 im re) #s(literal 1/2 binary64)))
(pow.f64 (sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1 binary64))
(pow.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal 1/2 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (*.f64 (+.f64 im re) (-.f64 im re)) #s(literal -1/2 binary64)))
(sqrt.f64 (*.f64 (+.f64 im re) (-.f64 im re)))
(exp.f64 (.f64 (log.f64 (.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1/2 binary64)))
(*.f64 (+.f64 im re) (-.f64 im re))
(/.f64 (-.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (fma.f64 (.f64 (.f64 im im) im) im (fma.f64 (.f64 (.f64 re re) re) re (.f64 (.f64 im im) (*.f64 re re)))))
(/.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 im re) (-.f64 im re))) (fma.f64 re re (.f64 im im)))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 (neg.f64 re) re))
(fma.f64 (fabs.f64 im) (fabs.f64 im) (*.f64 (neg.f64 re) re))
(fma.f64 im im (*.f64 (neg.f64 re) re))
(-.f64 (.f64 im im) (.f64 re re))
(+.f64 (.f64 im im) (.f64 (neg.f64 re) re))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (*.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (neg.f64 (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re)) (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) im) im))) (.f64 re re)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re)) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) im)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) im) im))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re) (log.f64 im)))
#s(approx (log (+ (* im im) (* re re))) (*.f64 (log.f64 im) #s(literal 2 binary64)))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 im) #s(literal 2 binary64) (/.f64 (.f64 re re) (.f64 im im))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 im) #s(literal 2 binary64) (.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 im im))) (*.f64 re re))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 im) #s(literal 2 binary64) (.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/3 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (.f64 im im) im) im))) (.f64 re re) (/.f64 #s(literal 1 binary64) (.f64 im im))) (.f64 re re))))
#s(approx (+ (* im im) (* re re)) (*.f64 im im))
#s(approx (+ (* im im) (* re re)) (fma.f64 re re (*.f64 im im)))
#s(approx (* re re) (*.f64 re re))
#s(approx re re)
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 im im))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 re re)) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)))) (/.f64 #s(literal 1/4 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (.f64 im im) im) im)))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 im im)))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) im)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) im) im))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re) (log.f64 im)))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) im)
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) im)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/16 binary64) (.f64 re re)) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 im im) im))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (neg re) (neg.f64 re))
#s(approx (neg (log (/ -1 re))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (/ -1 re)) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (/ -1 re) (/.f64 #s(literal -1 binary64) re))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (*.f64 im im))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 im im)) #s(literal -1/2 binary64) (*.f64 im im)))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (fma.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/8 binary64)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 (.f64 (.f64 re re) re) re) (.f64 im im)))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (fma.f64 (-.f64 (.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (pow.f64 im #s(literal 10 binary64))) #s(literal -1/16 binary64)) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)))) (.f64 (.f64 (.f64 re re) re) re)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 (.f64 (.f64 re re) re) re) (.f64 im im)))
#s(approx (sqrt (- (* im im) (* re re))) im)
#s(approx (sqrt (- (* im im) (* re re))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal -1/2 binary64) im))
#s(approx (sqrt (- (* im im) (* re re))) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal -1/8 binary64) (.f64 re re)) (.f64 (.f64 im im) im)) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im))
#s(approx (sqrt (- (* im im) (* re re))) (fma.f64 (-.f64 (.f64 (-.f64 (/.f64 (.f64 #s(literal -1/16 binary64) (.f64 re re)) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 im im) im))) (.f64 re re)) (/.f64 #s(literal 1/2 binary64) im)) (*.f64 re re) im))
#s(approx (- (* im im) (* re re)) (*.f64 im im))
#s(approx (- (* im im) (* re re)) (fma.f64 im im (neg.f64 (*.f64 re re))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (*.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal -1/2 binary64) (neg.f64 (log.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/6 binary64)) (log.f64 re)) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 re))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re))) (log.f64 re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))) (log.f64 re)))
#s(approx (log (+ (* im im) (* re re))) (*.f64 (log.f64 re) #s(literal 2 binary64)))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 re) #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 re) #s(literal 2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 re) #s(literal 2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/3 binary64) (/.f64 (.f64 im im) (.f64 re re))))))
#s(approx (+ (* im im) (* re re)) (*.f64 re re))
#s(approx (+ (* im im) (* re re)) (.f64 (+.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))))) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 re))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re))) (log.f64 re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) (log.f64 re)))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64)) re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (neg (log (/ -1 re))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (/ -1 re)) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 re re)))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 (.f64 (.f64 re re) re) re))) #s(literal 1/2 binary64) (sqrt.f64 #s(literal -1 binary64))) (*.f64 re re)))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 im im) im) im)) (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 re re) re) re)))) #s(literal -1/8 binary64) (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 (.f64 (.f64 re re) re) re))) #s(literal 1/2 binary64))) (sqrt.f64 #s(literal -1 binary64))) (.f64 re re)))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 im im) im) im)) (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 re re) re) re)))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 im im) im) im)) (.f64 (.f64 (.f64 im im) im) im)) (.f64 (pow.f64 #s(literal -1 binary64) #s(literal 5/2 binary64)) (.f64 (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 re re) re) re)) (.f64 (.f64 (.f64 re re) re) re)))) #s(literal 1/16 binary64) (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 (.f64 (.f64 re re) re) re))) #s(literal 1/2 binary64)))) (sqrt.f64 #s(literal -1 binary64))) (*.f64 re re)))
#s(approx (sqrt (- (* im im) (* re re))) (*.f64 (sqrt.f64 #s(literal -1 binary64)) re))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 re re))) #s(literal 1/2 binary64) (sqrt.f64 #s(literal -1 binary64))) re))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (.f64 (.f64 (.f64 re re) re) re))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 re re)))) (sqrt.f64 #s(literal -1 binary64))) re))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (.f64 (.f64 (.f64 re re) re) re))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (pow.f64 #s(literal -1 binary64) #s(literal 5/2 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 re re))))) (sqrt.f64 #s(literal -1 binary64))) re))
#s(approx (- (* im im) (* re re)) (neg.f64 (*.f64 re re)))
#s(approx (- (* im im) (* re re)) (.f64 (-.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (*.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/6 binary64)) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re))))))
#s(approx (log (+ (* im im) (* re re))) (*.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re))) (/.f64 (.f64 im im) (.f64 re re))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 #s(literal -2 binary64) (neg.f64 (log.f64 (neg.f64 re))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/3 binary64) (/.f64 (.f64 im im) (.f64 re re))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) #s(literal 1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (+.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (+.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 10 binary64)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re)))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 re) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64))))
#s(approx (neg (log (/ -1 re))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (/ -1 re)) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (sqrt (- (* im im) (* re re))) (*.f64 (neg.f64 re) (sqrt.f64 #s(literal -1 binary64))))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (neg.f64 re) (fma.f64 (/.f64 (.f64 im im) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 re re))) #s(literal 1/2 binary64) (sqrt.f64 #s(literal -1 binary64)))))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (.f64 (.f64 (.f64 re re) re) re))) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 re re)))) (sqrt.f64 #s(literal -1 binary64)))))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (.f64 (.f64 (.f64 re re) re) re))) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (pow.f64 #s(literal -1 binary64) #s(literal 5/2 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 re re))))) (sqrt.f64 #s(literal -1 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 im im)) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (*.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal -1/2 binary64) (neg.f64 (log.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 im im)) (.f64 (.f64 (.f64 re re) re) re)) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (neg.f64 (log.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) re) re))) (.f64 im im)) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (neg.f64 (log.f64 re))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 re))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im) (log.f64 re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 im im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) re) re))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (log.f64 re)))
#s(approx (log (+ (* im im) (* re re))) (*.f64 (log.f64 re) #s(literal 2 binary64)))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 re) #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (*.f64 (log.f64 re) #s(literal 2 binary64))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/3 binary64) (.f64 im im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (.f64 re re) re) re))) (.f64 im im) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (.f64 (log.f64 re) #s(literal 2 binary64))))
#s(approx im im)
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 re re))) #s(literal 1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 10 binary64)))) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re)))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 im im)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 10 binary64)))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 10 binary64))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 re re)))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 re))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im) (log.f64 re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 im im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) re) re))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (log.f64 re)))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) re)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/16 binary64) (.f64 im im)) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 re re) re))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 re re))) #s(literal 1/2 binary64) (.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 re re))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (fma.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 re re)))) (.f64 (.f64 (.f64 im im) im) im) (.f64 (sqrt.f64 #s(literal -1 binary64)) (*.f64 re re))))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (fma.f64 (fma.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (pow.f64 re #s(literal 10 binary64)) (pow.f64 #s(literal -1 binary64) #s(literal 5/2 binary64)))) #s(literal 1/16 binary64)) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))))) (.f64 (.f64 (.f64 im im) im) im) (/.f64 #s(literal 1/2 binary64) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 re re)))) (.f64 (.f64 (.f64 im im) im) im) (.f64 (sqrt.f64 #s(literal -1 binary64)) (.f64 re re))))
#s(approx (* im im) (*.f64 im im))
#s(approx (sqrt (- (* im im) (* re re))) (fma.f64 (/.f64 (.f64 im im) (.f64 (sqrt.f64 #s(literal -1 binary64)) re)) #s(literal 1/2 binary64) (*.f64 (sqrt.f64 #s(literal -1 binary64)) re)))
#s(approx (sqrt (- (* im im) (* re re))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) re) (.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal -1 binary64)))) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 (sqrt.f64 #s(literal -1 binary64)) re))) (.f64 im im) (.f64 (sqrt.f64 #s(literal -1 binary64)) re)))
#s(approx (sqrt (- (* im im) (* re re))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/16 binary64) (.f64 im im)) (pow.f64 (.f64 (sqrt.f64 #s(literal -1 binary64)) re) #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 (.f64 re re) re) (.f64 (sqrt.f64 #s(literal -1 binary64)) #s(literal -1 binary64))))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 (sqrt.f64 #s(literal -1 binary64)) re))) (.f64 im im) (*.f64 (sqrt.f64 #s(literal -1 binary64)) re)))
#s(approx (- (* im im) (* re re)) (*.f64 (+.f64 im re) (-.f64 im re)))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (*.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (neg.f64 (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/6 binary64)) (log.f64 im)) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im))) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im)))) (log.f64 im)))
#s(approx (log (+ (* im im) (* re re))) (*.f64 (log.f64 im) #s(literal 2 binary64)))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 im) #s(literal 2 binary64) (/.f64 (.f64 re re) (.f64 im im))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 im) #s(literal 2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (log.f64 im) #s(literal 2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/3 binary64) (/.f64 (.f64 re re) (.f64 im im))))))
#s(approx (+ (* im im) (* re re)) (.f64 (+.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 im im))) #s(literal 1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 im im)))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 im im))))) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im))) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) (log.f64 im)))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))) #s(literal 1 binary64)) im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) #s(literal 1 binary64)) im))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) #s(literal 1 binary64)) (.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 re re) re) re)) (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/8 binary64))) (*.f64 im im)))
#s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 re re) re) re)) (.f64 (.f64 (.f64 re re) re) re)) (.f64 (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 im im) im) im)) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/16 binary64) (.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 re re) re) re)) (.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/8 binary64)))) #s(literal 1 binary64)) (*.f64 im im)))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) #s(literal 1 binary64)) (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64))) im))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/16 binary64) (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64)))) #s(literal 1 binary64)) im))
#s(approx (- (* im im) (* re re)) (.f64 (+.f64 (/.f64 (neg.f64 (.f64 re re)) (.f64 im im)) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (*.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (*.f64 im im)) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/6 binary64)) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/6 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im))))))
#s(approx (log (+ (* im im) (* re re))) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -2 binary64)))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -2 binary64) (/.f64 (.f64 re re) (.f64 im im))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)))))
#s(approx (log (+ (* im im) (* re re))) (fma.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/3 binary64) (/.f64 (.f64 re re) (.f64 im im))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 im im))) #s(literal 1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (+.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 im im))))))
#s(approx (/ (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log 10)) (+.f64 (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (.f64 im im) im) im))) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (log.f64 #s(literal 10 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 (log.f64 #s(literal 10 binary64)) (*.f64 im im)))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 im) (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))) #s(literal 1 binary64))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) #s(literal 1 binary64))))
#s(approx (sqrt (- (* im im) (* re re))) (neg.f64 im))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (neg.f64 im) (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal -1/2 binary64) #s(literal 1 binary64))))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) #s(literal 1 binary64)) (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64)))))
#s(approx (sqrt (- (* im im) (* re re))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/16 binary64) (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64)))) #s(literal 1 binary64))))

eval31.0ms (1.2%)

Memory: 16.4MiB live, 61.9MiB allocated; 5ms collecting garbage
Compiler: Compiled 13 996 to 1 630 computations (88.4% saved)

prune12.0ms (0.5%)

Memory

-31.9MiB live, 21.9MiB allocated; 5ms collecting garbage

Pruning

12 alts after pruning (7 fresh and 5 done)

	Pruned	Kept	Total
New	305	7	312
Fresh	0	0	0
Picked	3	2	5
Done	1	3	4
Total	309	12	321

Accuracy

99.7%

Counts

321 → 12

Alt Table

Click to see full alt table

Status	Accuracy	Program
▶	54.0%	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
▶	0.0%	(/.f64 (neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
▶	10.5%	(/.f64 (neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re))) (log.f64 #s(literal 1/10 binary64)))
▶	98.7%	(/.f64 (neg.f64 #s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
	52.5%	(/.f64 (log.f64 (/.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im)) (exp.f64 (.f64 (log.f64 (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1/2 binary64))))) (log.f64 #s(literal 10 binary64)))
	0.2%	(/.f64 (log.f64 (/.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im)) #s(approx (sqrt (- ( im im) (* re re))) (neg.f64 im)))) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
✓	10.5%	(/.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
✓	98.8%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
▶	0.0%	(/.f64 #s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))

Compiler

Compiled 501 to 303 computations (39.5% saved)

series64.0ms (2.5%)

Memory

36.7MiB live, 129.8MiB allocated; 6ms collecting garbage

Counts

28 → 233

Calls

Call 1

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

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

Calls

6 calls:

Time	Variable		Point	Expression
18.0ms	im	@	inf	((/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log im) im (log 1/10) 1/10 (/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg (log (neg im))) (log (neg im)) (neg im) (/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg re) (/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10)) (* -1/2 (log (+ (* re re) (* im im)))) -1/2 (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im))
17.0ms	im	@	0	((/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log im) im (log 1/10) 1/10 (/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg (log (neg im))) (log (neg im)) (neg im) (/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg re) (/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10)) (* -1/2 (log (+ (* re re) (* im im)))) -1/2 (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im))
16.0ms	im	@	-inf	((/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log im) im (log 1/10) 1/10 (/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg (log (neg im))) (log (neg im)) (neg im) (/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg re) (/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10)) (* -1/2 (log (+ (* re re) (* im im)))) -1/2 (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im))
3.0ms	re	@	inf	((/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log im) im (log 1/10) 1/10 (/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg (log (neg im))) (log (neg im)) (neg im) (/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg re) (/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10)) (* -1/2 (log (+ (* re re) (* im im)))) -1/2 (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im))
2.0ms	re	@	0	((/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log im) im (log 1/10) 1/10 (/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg (log (neg im))) (log (neg im)) (neg im) (/ (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log 1/10)) (neg (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))))) (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg re) (/ (* -1/2 (log (+ (* re re) (* im im)))) (log 1/10)) (* -1/2 (log (+ (* re re) (* im im)))) -1/2 (log (+ (* re re) (* im im))) (+ (* re re) (* im im)) (* im im))

rewrite201.0ms (7.7%)

Memory

-13.0MiB live, 269.0MiB allocated; 46ms collecting garbage

Iterations

Useful iterations: 0 (0.0ms)

Iter	Nodes	Cost
0	716	9555
0	747	7130
1	3912	6953
0	8952	5889

Stop Event

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

Counts

261 → 337

Calls

Call 1

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

Outputs
(/.f64 (neg.f64 (neg.f64 #s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 #s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (/.f64 #s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im)) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 #s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im))
(*.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64))
(.f64 (.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 1/2 binary64))
(*.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(.f64 #s(literal 1/2 binary64) (.f64 #s(literal 2 binary64) (log.f64 im)))
(neg.f64 (neg.f64 (log.f64 im)))
(log.f64 im)
im
(log.f64 #s(literal 1/10 binary64))
#s(literal 1/10 binary64)
(/.f64 (neg.f64 (neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (/.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)))
(-.f64 #s(literal 0 binary64) (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)))
(log.f64 (/.f64 #s(literal 1 binary64) #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)))
(log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)
re
(/.f64 (neg.f64 #s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 im))))) (log.f64 #s(literal 10 binary64)))
(/.f64 #s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 im))))
(*.f64 (log.f64 (neg.f64 im)) #s(literal -1 binary64))
(*.f64 #s(literal -1 binary64) (log.f64 (neg.f64 im)))
(neg.f64 (log.f64 (neg.f64 im)))
(fma.f64 (log.f64 #s(literal -1 binary64)) #s(literal -1 binary64) (neg.f64 (log.f64 im)))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 im)))
(-.f64 #s(literal 0 binary64) (log.f64 (neg.f64 im)))
(-.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im))
(+.f64 (*.f64 (log.f64 #s(literal -1 binary64)) #s(literal -1 binary64)) (neg.f64 (log.f64 im)))
(+.f64 (log.f64 #s(literal -1 binary64)) (neg.f64 (log.f64 im)))
(log.f64 (/.f64 #s(literal -1 binary64) im))
(/.f64 (-.f64 (pow.f64 (log.f64 #s(literal -1 binary64)) #s(literal 2 binary64)) (pow.f64 (log.f64 im) #s(literal 2 binary64))) (neg.f64 (log.f64 (neg.f64 im))))
(/.f64 (+.f64 (pow.f64 (log.f64 #s(literal -1 binary64)) #s(literal 3 binary64)) (pow.f64 (log.f64 im) #s(literal 3 binary64))) (+.f64 (pow.f64 (log.f64 #s(literal -1 binary64)) #s(literal 2 binary64)) (-.f64 (pow.f64 (log.f64 im) #s(literal 2 binary64)) (*.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im)))))
(fma.f64 (neg.f64 (log.f64 im)) #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)))
(fma.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)) #s(literal 1/2 binary64) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal -1 binary64) (neg.f64 (log.f64 im)) (log.f64 #s(literal -1 binary64)))
(fma.f64 #s(literal -1 binary64) (log.f64 #s(literal -1 binary64)) (log.f64 im))
(fma.f64 #s(literal 1/2 binary64) (*.f64 #s(literal 2 binary64) (log.f64 im)) (log.f64 #s(literal -1 binary64)))
(-.f64 (log.f64 #s(literal -1 binary64)) (*.f64 #s(literal 1 binary64) (neg.f64 (log.f64 im))))
(+.f64 (log.f64 #s(literal -1 binary64)) (log.f64 im))
(+.f64 (log.f64 im) (log.f64 #s(literal -1 binary64)))
(log.f64 (neg.f64 im))
(*.f64 #s(literal -1 binary64) im)
(*.f64 im #s(literal -1 binary64))
(neg.f64 im)
(/.f64 (neg.f64 (neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))))) (log.f64 #s(literal 10 binary64)))
(/.f64 (neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
(neg.f64 (/.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
(neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))))
(-.f64 #s(literal 0 binary64) (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))))
(log.f64 (/.f64 #s(literal 1 binary64) #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))))
(log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re)))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))
(*.f64 #s(literal -1 binary64) re)
(*.f64 re #s(literal -1 binary64))
(neg.f64 re)
(.f64 #s(literal -1/2 binary64) (/.f64 (log.f64 (fma.f64 re re (.f64 im im))) (log.f64 #s(literal 1/10 binary64))))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64)) (log.f64 #s(literal 1/10 binary64)))
(/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 10 binary64)))
(neg.f64 (/.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)) (log.f64 #s(literal 1/10 binary64))))
(.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal -1/2 binary64))
(.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im))))
(.f64 #s(literal 1/2 binary64) (neg.f64 (log.f64 (fma.f64 re re (.f64 im im)))))
(neg.f64 (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)))
(-.f64 #s(literal 0 binary64) (.f64 (log.f64 (fma.f64 re re (.f64 im im))) #s(literal 1/2 binary64)))
(log.f64 (/.f64 #s(literal 1 binary64) (sqrt.f64 (fma.f64 re re (*.f64 im im)))))
#s(literal -1/2 binary64)
(-.f64 (log.f64 (-.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im))) (log.f64 (-.f64 (.f64 re re) (.f64 im im))))
(-.f64 (log.f64 (fma.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)))) (log.f64 (fma.f64 (.f64 (.f64 re re) re) re (-.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 re re) (*.f64 im im))))))
(-.f64 (log.f64 (fma.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)))) (log.f64 (fma.f64 (.f64 (.f64 im im) im) im (-.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 im im) (*.f64 re re))))))
(-.f64 (log.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 im re) (-.f64 im re)))) (log.f64 (.f64 (+.f64 im re) (-.f64 im re))))
(log.f64 (fma.f64 re re (*.f64 im im)))
(/.f64 (-.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) (-.f64 (.f64 re re) (.f64 im im)))
(/.f64 (fma.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) (fma.f64 (.f64 (.f64 re re) re) re (-.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 re re) (*.f64 im im)))))
(/.f64 (fma.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (fma.f64 (.f64 (.f64 im im) im) im (-.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 im im) (*.f64 re re)))))
(/.f64 (.f64 (fma.f64 re re (.f64 im im)) (.f64 (+.f64 im re) (-.f64 im re))) (.f64 (+.f64 im re) (-.f64 im re)))
(fma.f64 (neg.f64 (neg.f64 re)) (neg.f64 (neg.f64 re)) (*.f64 im im))
(fma.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)) (*.f64 re re))
(fma.f64 (neg.f64 im) (neg.f64 im) (*.f64 re re))
(fma.f64 (neg.f64 re) (neg.f64 re) (*.f64 im im))
(fma.f64 re re (*.f64 im im))
(fma.f64 im im (*.f64 re re))
(-.f64 (.f64 im im) (.f64 (neg.f64 re) re))
(-.f64 (.f64 re re) (.f64 (neg.f64 im) im))
(+.f64 (.f64 im im) (.f64 re re))
(+.f64 (.f64 re re) (.f64 im im))
(*.f64 (neg.f64 (neg.f64 im)) (neg.f64 (neg.f64 im)))
(*.f64 (neg.f64 im) (neg.f64 im))
(*.f64 im im)
(pow.f64 (neg.f64 im) #s(literal 2 binary64))
(pow.f64 (/.f64 #s(literal 1 binary64) im) #s(literal -2 binary64))
(pow.f64 (*.f64 im im) #s(literal 1 binary64))
(pow.f64 im #s(literal 2 binary64))
(/.f64 #s(literal 1 binary64) (pow.f64 (/.f64 #s(literal 1 binary64) im) #s(literal 2 binary64)))
(sqrt.f64 (.f64 (.f64 (*.f64 im im) im) im))
(fabs.f64 (neg.f64 (*.f64 im im)))
(fabs.f64 (*.f64 im im))
(exp.f64 (*.f64 #s(literal 2 binary64) (log.f64 im)))
(+.f64 (cosh.f64 (.f64 #s(literal 2 binary64) (log.f64 im))) (sinh.f64 (.f64 #s(literal 2 binary64) (log.f64 im))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (*.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (neg.f64 (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re)) (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) im) im))) (.f64 re re)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re)) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 #s(literal -1/4 binary64) (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) im)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) im) im))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (*.f64 re re) (log.f64 im)))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) im)
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (/.f64 (*.f64 re re) im) #s(literal 1/2 binary64) im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) im)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/16 binary64) (.f64 re re)) (pow.f64 im #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 im im) im))) (.f64 re re) (/.f64 #s(literal 1/2 binary64) im)) (.f64 re re) im))
#s(approx re re)
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (*.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (neg.f64 (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re)) (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) im) im))) (.f64 re re)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re)) (log.f64 im)))
#s(approx (neg re) (neg.f64 re))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (*.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64))))) (.f64 re re) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (neg.f64 (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) im)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re)) (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 im im) im) im))) (.f64 re re)) (/.f64 #s(literal 1/2 binary64) (.f64 im im))) (.f64 re re)) (log.f64 im)))
#s(approx (log (+ (* re re) (* im im))) (*.f64 #s(literal 2 binary64) (log.f64 im)))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 #s(literal 2 binary64) (log.f64 im) (/.f64 (.f64 re re) (.f64 im im))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 im im))) (.f64 re re) (*.f64 #s(literal 2 binary64) (log.f64 im))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/3 binary64) (.f64 re re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (.f64 im im) im) im))) (.f64 re re) (/.f64 #s(literal 1 binary64) (.f64 im im))) (.f64 re re) (.f64 #s(literal 2 binary64) (log.f64 im))))
#s(approx (+ (* re re) (* im im)) (*.f64 im im))
#s(approx (+ (* re re) (* im im)) (fma.f64 re re (*.f64 im im)))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/720 binary64)) (log.f64 re)) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 re))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (log.f64 re) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64)) re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64)) re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64)) re))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (*.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (log.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/6 binary64)) (log.f64 re)) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (*.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re))) (neg.f64 (log.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/6 binary64) (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (*.f64 re re) re) re)) #s(literal 1/4 binary64)))) (neg.f64 (log.f64 re))))
#s(approx (log (+ (* re re) (* im im))) (*.f64 (log.f64 re) #s(literal 2 binary64)))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (log.f64 re) #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (log.f64 re) #s(literal 2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (log.f64 re) #s(literal 2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/3 binary64) (/.f64 (.f64 im im) (.f64 re re))))))
#s(approx (+ (* re re) (* im im)) (*.f64 re re))
#s(approx (+ (* re re) (* im im)) (.f64 (+.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1 binary64)) (.f64 re re)))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/720 binary64)) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (*.f64 re re)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (fma.f64 #s(literal 1/720 binary64) (/.f64 (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 re) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))) #s(literal 1 binary64))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 re) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re)))) #s(literal 1 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (*.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (neg.f64 (neg.f64 (log.f64 (neg.f64 re))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 im im) (*.f64 re re)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/6 binary64)) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 re)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 im im)) (.f64 re re))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 (*.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 re))) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal -1/2 binary64) (neg.f64 (log.f64 (neg.f64 re)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal -1/2 binary64) (neg.f64 (log.f64 (neg.f64 re)))) (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (*.f64 re re) re) re)) #s(literal 1/4 binary64))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (+.f64 (neg.f64 (log.f64 (neg.f64 re))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/6 binary64) (.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (*.f64 re re) re) re)) #s(literal 1/4 binary64))))))
#s(approx (log (+ (* re re) (* im im))) (*.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -2 binary64)))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -2 binary64) (/.f64 (.f64 im im) (.f64 re re))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/2 binary64) (/.f64 (.f64 im im) (.f64 re re)))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (neg.f64 (log.f64 (neg.f64 re))) #s(literal -2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal 1/3 binary64) (/.f64 (.f64 im im) (.f64 re re))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 im im)) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (*.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 im im)) (.f64 (.f64 (.f64 re re) re) re)) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (neg.f64 (log.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) re) re))) (.f64 im im)) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (neg.f64 (log.f64 re))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 re))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 im im) (.f64 re re)) #s(literal 1/2 binary64) (log.f64 re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/4 binary64) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (.f64 im im) (log.f64 re)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/6 binary64) (.f64 im im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) re) re))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (log.f64 re)))
#s(approx (log im) (log.f64 im))
#s(approx im im)
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (/.f64 (*.f64 im im) re) #s(literal 1/2 binary64) re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 re re) re)) #s(literal -1/8 binary64) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/16 binary64) (.f64 im im)) (pow.f64 re #s(literal 5 binary64))) (/.f64 #s(literal 1/8 binary64) (.f64 (.f64 re re) re))) (.f64 im im) (/.f64 #s(literal 1/2 binary64) re)) (.f64 im im) re))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 im im)) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (*.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 im im)) (.f64 (.f64 (.f64 re re) re) re)) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (neg.f64 (log.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) re) re))) (.f64 im im)) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (neg.f64 (log.f64 re))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (log (neg im)) (log.f64 (neg.f64 im)))
#s(approx (neg im) (neg.f64 im))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 im im) (.f64 (*.f64 re re) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 im im)) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64)))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (*.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 (.f64 re re) re) re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im)) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 re re) (log.f64 #s(literal 1/10 binary64))))) (.f64 im im) (/.f64 (log.f64 re) (log.f64 #s(literal 10 binary64)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 im im)) (*.f64 re re)) (log.f64 re)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/4 binary64) (.f64 im im)) (.f64 (.f64 (.f64 re re) re) re)) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (neg.f64 (log.f64 re))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (-.f64 (.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) #s(literal -1/6 binary64) (/.f64 #s(literal 1/4 binary64) (.f64 (.f64 (.f64 re re) re) re))) (.f64 im im)) (/.f64 #s(literal 1/2 binary64) (.f64 re re))) (*.f64 im im) (neg.f64 (log.f64 re))))
#s(approx (log (+ (* re re) (* im im))) (*.f64 (log.f64 re) #s(literal 2 binary64)))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (log.f64 re) #s(literal 2 binary64) (/.f64 (.f64 im im) (.f64 re re))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (fma.f64 (/.f64 (.f64 im im) (.f64 (.f64 (.f64 re re) re) re)) #s(literal -1/2 binary64) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (*.f64 (log.f64 re) #s(literal 2 binary64))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (fma.f64 (-.f64 (/.f64 (.f64 #s(literal 1/3 binary64) (.f64 im im)) (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re))) (/.f64 #s(literal 1/2 binary64) (.f64 (.f64 (.f64 re re) re) re))) (.f64 im im) (/.f64 #s(literal 1 binary64) (.f64 re re))) (.f64 im im) (.f64 (log.f64 re) #s(literal 2 binary64))))
#s(approx (* im im) (*.f64 im im))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (neg.f64 (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/720 binary64)) (log.f64 im)) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im))) (log.f64 im)))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) (log.f64 im)))
#s(approx (log im) (log.f64 im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64)) im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))) #s(literal 1 binary64)) im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) #s(literal 1 binary64)) im))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (*.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (neg.f64 (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/6 binary64)) (log.f64 im)) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (log (neg im)) (log.f64 (neg.f64 im)))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (*.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (log.f64 im) (log.f64 #s(literal 10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 im)))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (neg.f64 (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal 1/4 binary64) (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (*.f64 im im))) (neg.f64 (log.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/6 binary64) (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (*.f64 im im) im) im)) #s(literal 1/4 binary64)))) (neg.f64 (log.f64 im))))
#s(approx (log (+ (* re re) (* im im))) (*.f64 #s(literal 2 binary64) (log.f64 im)))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 #s(literal 2 binary64) (log.f64 im) (/.f64 (.f64 re re) (.f64 im im))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 #s(literal 2 binary64) (log.f64 im) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/3 binary64) (/.f64 (.f64 re re) (.f64 im im))))))
#s(approx (+ (* re re) (* im im)) (.f64 (+.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1 binary64)) (.f64 im im)))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/720 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (*.f64 im im)) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/720 binary64)) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (*.f64 im im)))))
#s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) #s(literal 120 binary64)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/720 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))))))
#s(approx (log im) (log.f64 (*.f64 (/.f64 #s(literal 1 binary64) (/.f64 #s(literal -1 binary64) im)) #s(literal -1 binary64))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 im))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 im) (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) #s(literal 1 binary64))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))) #s(literal 1 binary64))))
#s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (.f64 (neg.f64 im) (+.f64 (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/8 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/16 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im)))) #s(literal 1 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (*.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (/.f64 (.f64 #s(literal -1/2 binary64) (.f64 re re)) (*.f64 im im)) (neg.f64 (neg.f64 (log.f64 (neg.f64 im))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal 1/4 binary64)) (fma.f64 (/.f64 (.f64 re re) (*.f64 im im)) #s(literal 1/2 binary64) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (-.f64 (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/6 binary64)) (+.f64 (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/4 binary64) (/.f64 (.f64 #s(literal 1/2 binary64) (.f64 re re)) (.f64 im im))))))
#s(approx (neg (log (neg im))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (log (neg im)) (neg.f64 (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (*.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64))))))
#s(approx (/ (neg (* 1/2 (log (+ (* im im) (* re re))))) (log 1/10)) (fma.f64 (/.f64 (.f64 re re) (.f64 (.f64 im im) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im)) (log.f64 #s(literal 1/10 binary64)))) #s(literal -1/6 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 (*.f64 im im) im) im) (log.f64 #s(literal 1/10 binary64)))) #s(literal 1/4 binary64) (/.f64 (neg.f64 (log.f64 (neg.f64 im))) (log.f64 #s(literal 1/10 binary64)))))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 im))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (neg.f64 (log.f64 (neg.f64 im)))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (neg.f64 (log.f64 (neg.f64 im)))) (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (*.f64 im im) im) im)) #s(literal 1/4 binary64))))
#s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (+.f64 (fma.f64 (/.f64 (.f64 re re) (.f64 im im)) #s(literal -1/2 binary64) (neg.f64 (log.f64 (neg.f64 im)))) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal -1/6 binary64) (.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (*.f64 im im) im) im)) #s(literal 1/4 binary64)))))
#s(approx (log (+ (* re re) (* im im))) (*.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -2 binary64)))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -2 binary64) (/.f64 (.f64 re re) (.f64 im im))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) (/.f64 (.f64 re re) (.f64 im im)))))
#s(approx (log (+ (* re re) (* im im))) (fma.f64 (neg.f64 (log.f64 (neg.f64 im))) #s(literal -2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) re) (.f64 (.f64 (.f64 im im) im) im)) #s(literal -1/2 binary64) (fma.f64 (/.f64 (.f64 (.f64 (.f64 re re) re) (.f64 (.f64 re re) re)) (.f64 (.f64 (.f64 im im) im) (.f64 (.f64 im im) im))) #s(literal 1/3 binary64) (/.f64 (.f64 re re) (.f64 im im))))))

eval24.0ms (0.9%)

Memory: -1.5MiB live, 45.0MiB allocated; 4ms collecting garbage
Compiler: Compiled 8 387 to 1 060 computations (87.4% saved)

prune9.0ms (0.3%)

Memory

23.5MiB live, 23.5MiB allocated; 0ms collecting garbage

Pruning

12 alts after pruning (2 fresh and 10 done)

	Pruned	Kept	Total
New	214	0	214
Fresh	0	2	2
Picked	0	5	5
Done	0	5	5
Total	214	12	226

Accuracy

99.7%

Counts

226 → 12

Alt Table

Click to see full alt table

Status	Accuracy	Program
✓	54.0%	(/.f64 (.f64 #s(literal -1/2 binary64) (log.f64 (fma.f64 re re (.f64 im im)))) (log.f64 #s(literal 1/10 binary64)))
✓	0.0%	(/.f64 (neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re)))) (log.f64 #s(literal 1/10 binary64)))
✓	10.5%	(/.f64 (neg.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re))) (log.f64 #s(literal 1/10 binary64)))
✓	98.7%	(/.f64 (neg.f64 #s(approx (log (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re))))) (log.f64 im))) (log.f64 #s(literal 1/10 binary64)))
✓	99.1%	(/.f64 (log.f64 (hypot.f64 re im)) (log.f64 #s(literal 10 binary64)))
	52.5%	(/.f64 (log.f64 (/.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im)) (exp.f64 (.f64 (log.f64 (*.f64 (+.f64 im re) (-.f64 im re))) #s(literal 1/2 binary64))))) (log.f64 #s(literal 10 binary64)))
	0.2%	(/.f64 (log.f64 (/.f64 #s(approx (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (.f64 im im)) #s(approx (sqrt (- ( im im) (* re re))) (neg.f64 im)))) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) (neg.f64 re))) (log.f64 #s(literal 10 binary64)))
✓	10.5%	(/.f64 (log.f64 #s(approx (/ (sqrt (- (* (* im im) (* im im)) (* (* re re) (* re re)))) (sqrt (- (* im im) (* re re)))) re)) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) (neg.f64 im))) (log.f64 #s(literal 10 binary64)))
✓	98.8%	(/.f64 (log.f64 #s(approx (sqrt (+ (* re re) (* im im))) im)) (log.f64 #s(literal 10 binary64)))
✓	0.0%	(/.f64 #s(approx (neg (* 1/2 (log (+ (* im im) (* re re))))) (neg.f64 (log.f64 (neg.f64 im)))) (log.f64 #s(literal 1/10 binary64)))

Compiler

Compiled 763 to 291 computations (61.9% saved)

regimes45.0ms (1.7%)

Memory

-2.0MiB live, 91.0MiB allocated; 6ms collecting garbage

Counts

20 → 1

Calls

Call 1

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

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

regimes42.0ms (1.6%)

Memory

-20.2MiB live, 75.9MiB allocated; 7ms collecting garbage

Accuracy

Total -63.2b remaining (-8259%)

Threshold costs -63.2b (-8259%)

Counts

18 → 1

Calls

Call 1

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

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

Calls

8 calls:

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

Results

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

Compiler

Compiled 44 to 38 computations (13.6% saved)

derivations50.0ms (1.9%)

Memory

22.4MiB live, 68.9MiB allocated; 3ms collecting garbage

Stop Event

1×

fuel

Compiler

Compiled 21 to 14 computations (33.3% saved)

preprocess25.0ms (1%)

Memory: 11.6MiB live, 57.3MiB allocated; 4ms collecting garbage
Compiler: Compiled 192 to 156 computations (18.8% saved)

end0.0ms (0%)

Memory: 0.0MiB live, 0.0MiB allocated; 0ms collecting garbage

start0.0ms (0%)

analyze68.0ms (2.6%)

sample918.0ms (35.3%)

explain164.0ms (6.3%)

preprocess8.0ms (0.3%)

series34.0ms (1.3%)

rewrite213.0ms (8.2%)

eval24.0ms (0.9%)

prune10.0ms (0.4%)

series40.0ms (1.6%)

rewrite254.0ms (9.8%)

eval33.0ms (1.3%)

prune10.0ms (0.4%)

series120.0ms (4.6%)

rewrite199.0ms (7.7%)

eval31.0ms (1.2%)

prune12.0ms (0.5%)

series64.0ms (2.5%)

rewrite201.0ms (7.7%)

eval24.0ms (0.9%)

prune9.0ms (0.3%)

regimes45.0ms (1.7%)

regimes42.0ms (1.6%)

derivations50.0ms (1.9%)

preprocess25.0ms (1%)

end0.0ms (0%)

Profiling